VAAL-WIKI - Новые страницы [ru]

5 Bitcoin Casino List

2021-10-22T16:58:20Z

Eracornet70: Новая страница: «[https://www.instapaper.com/p/bodyease61 www.Goldbitcoincasino.com] <div id="toc" style="background: #f9f9f9;border: 1px solid #aaa;displa…»

[https://www.instapaper.com/p/bodyease61 www.Goldbitcoincasino.com] <div id="toc" style="background: #f9f9f9;border: 1px solid #aaa;display: table;margin-bottom: 1em;padding: 1em;width: 350px;"> Content <ul class="toc_list"> <li> [#toc-0 20+ Additional Bitcoin Casinos Reviewed] </li> <li> [#toc-1 Provably Fair] </li> </ul> </div> But since there are quite a lot of cryptocurrency portals, there is not always time to look for the most satisfactory option. It happens that because of this, some gamblers are content with the first gambling resource they come across, and this is sad. We will provide you with a list of the most respectable and developed bitcoin casinos according to our version. You will have to choose only the best of the best, which will allow you to gamble with cryptocurrency with the maximum return. Among those are FortuneJack, Satoshi Casino, CloudBet, mBit, BitCasino, Bovada Casino, and Primedice. <ul> <li>Considering that the network governs itself, the safety of the currency is second to none.</li> <li>Unfortunately, residents of the United States, the United Kingdom and various other countries are restricted.</li> <li>Only the most experienced online gambling venues have Bitcoin, Litecoin, Ethereum, or any other crypto at their disposal.</li> <li>Being well established they’re available in the UK, Canada, France, Spain, Japan, Thailand and a dozen other countries are accepted.</li> <li>Players can prove that a casino game is fair by entering ID and other information.</li> <li>Each day, a handful of different slots games developed by Playson are included in the “Game of the Day” promotion.</li> </ul> When selecting a casino, you need to be aware of the concept of wagering requirements. This is a minimum amount of wagering you need to do before you can cash out any winnings from your bonus. For example, if you havea $100 bonus with wagering requirements of ‘35 times’ then you will need to wager $3,500 before you can cash out your winnings. Before you choose a Bitcoin casino for its bonuses, check on the rollover requirements. There’s no point of claiming a humongous amount of reward that claims you roll it over 80 times or a one that won’t allow you to withdraw more than you have deposited. Some bonuses, may, well, too good to be true, and, yes, sometimes they are not valid. Last but definitely not least, how well is the online support of the casino. Fortunately this can be tested very easily by opening a ticket before spending a dime at the casino. A well supported Bitcoin casino will have multiple support channels such as social media, email support and an online chat with a rep ready to answer your questions right away. There are 2000+ games on mBit Casino and online support is available as well in the form of a chatroom. There is a robust support system to the website in the form on online ticketing, online chat and several social channels as well. <h2 id="toc-0">20+ Additional Bitcoin Casinos Reviewed</h2> We also assess how fast and reliable these systems are in practice. Withdrawal and deposit times, along with fees or limits, are all evaluated before each of the crypto casinos can be considered for a listing on this site. There are a lot of factors that go into making a good gambling site, but to be called one of the top Bitcoin casinos, none are more important than customer support. MBit is considered one of the most respected crypto casinos in the world as it guarantees payouts. The number of available games on this crypto casino is humongous. There are 5,000+ games from 34 well-known providers like Microgaming and NetEnt. Their game selection includes slots, roulette, baccarat, blackjack, poker, and video poker. Like all good crypto betting sites, FortuneJack asks for minimal information during registration. That said, the site’s help articles are so comprehensive that you’ll probably find the answer to your query without any support. While we’d like mBitcasino to include a phone line, the site’s customer service options are more than satisfactory. 7Bit offers numerous welcome bonuses along with a very popular loyalty program. The site was launched back in 2014 and is owned and ran by Direx N.V. Casinos. Another reason why eToro is the best option is that it offers a regulated cryptocurrency wallet. So after you buy Bitcoin you can keep some funds safe on eToro’s wallet and transfer the rest to your chosen Bitcoin casino. Withdrawals can be intitiated within your account section on the website in a few mouse clicks. <h3 id="toc-1">Provably Fair</h3> If you reach higher score than the dealer without exceeding 21, you are the winner. If you want to read more, check our special article on Bitcoin slots. Table games include card games like Blackjack, Poker, Baccarat and Red dog. Roulette is often categorized as a table game or a random number game. We also recommend you avoid buying coins from anyone over a forum. You wouldn’t know who you were dealing with, and you may find that they fail to deliver on their promise. Beware of other Bitcoin casinos not on this list, as they might now be trustworthy. Overall, playing on the best BTC casinos has lots of benefits. If you bet $10,000 worth of BTC and win $2,000, it won’t feel like much of a win if the price of Bitcoin sinks so much that your withdrawal is only worth $5,000. This is why choosing a licensed BTC casino becomes even more important. You will be able to play slots, jackpots, table games, live casino games and more. Loki Casino is licensed and regulated under Antillephone N.V. The casino features a variety of slot games, roulette, poker and table games. While gambling is done in BTC, Bitcoin Casino will accept deposits in a variety of cryptocurrencies, including LTC, DOGE and ETH. <h2 id="toc-2">Where Can I Buy Bitcoin To Play At A Casino?</h2> Although PlayAmo accepts Bitcoin, all bonuses are represented in fiat currencies . We like the fact that you can activate your welcome bonus immediately after registration, which reduces the chance of any problems when you’re claiming it. Like most sites, Cloudbet also offers customer service via email. It’s commonplace these days for almost everything on the web to offer a mobile version. While many casinos have developed apps you can download onto your mobile device, many others have taken the mobile-optimized approach to their website. Some online casinos only accept the coin because of this fact. Players can make deposits faster at an Ethereum casino than they can at a Bitcoin casino. The fees that come along with this crypto are generally noticably smaller than those for bitcoin as well.

10 Crypto Casino

2021-10-22T16:57:26Z

Eracornet70: Новая страница: «[https://www.instapaper.com/p/homeease20 http://www.GoldBitcoinCasino.com/] <div id="toc" style="background: #f9f9f9;border: 1px solid #aa…»

[https://www.instapaper.com/p/homeease20 http://www.GoldBitcoinCasino.com/] <div id="toc" style="background: #f9f9f9;border: 1px solid #aaa;display: table;margin-bottom: 1em;padding: 1em;width: 350px;"> Content <ul class="toc_list"> <li> [#toc-0 Write My Essay: The Best Cheap And Free Online Services] </li> <li> [#toc-1 Red Dog Casino] </li> </ul> </div> The site offers both casino and sports betting under the same platform and has great bonuses to go along with it. We try to keep it updated with current bonuses and promotions. It’s not uncommon to receive no deposit bonuses on your email, once you have registered your account. Bitcoin sportsbooks make it easier than ever to bet on different matches. It’s both easier and cheaper to bet with Bitcoin instead of fiat currencies on regular gambling sites. Bonuses and promotions can differ widely between various Bitcoin casinos and betting sites. As hard as they are to win, it’s the main goal of all players for a reason. A jackpot can either have a set value or be of the progressive kind. A progressive jackpot means that it will increase the more rounds are being played and lost. Most of the biggest jackpot games have all their machines connected around the world, meaning their jackpot value can reach astronomical numbers. All good Bitcoin casinos need to have a decent library of Bitcoin table games . At BitStarz we’ve got an incredible library of Bitcoin table games from some of the best providers around. <ul> <li>100% best customer service I have experienced with any online casino.</li> <li>MBit is considered one of the most respected crypto casinos in the world as it guarantees payouts.</li> <li>Simply put, this site covers all the bases of what goes into making a great crypto platform.</li> <li>No bonus codes are needed, just go to the site using the links on this page to get the bonuses.</li> <li>Bonus policy allows you to get more cryptocurrency for the game.</li> </ul> The relatively recent registration of this service did not prevent it from developing and gaining the attention of players from all over the world. Bitstarz is fast becoming one of the best bitcoin casinos in the industry. This proven fair casino offers over 1000 fair games and accepts various cryptocurrencies for deposits. Users appreciate this service for accepting a great number of fiat currencies and cryptocurrencies. It offers a large list of funds for withdrawing winnings. Also, users note the speed of payments, namely instant deposits and withdrawals. There are many advantages of playing at a Bitcoin casino too, such as no banks can ban you from depositing at a Bitcoin casino. Bitcoin casino reviews are extremely helpful in discovering any shady dealings that a Bitcoin live casino might be involved in. Just as well, there are many review aggregate sites out there that are specifically dedicated to reviewing online casinos. <h2 id="toc-0">Write My Essay: The Best Cheap And Free Online Services</h2> The catalog includes a good selection of slots and card games. Online casino gambling is illegal in various countries despite significant regulation. However, if you’re looking for something even better, how about playing your favorite casino games online? <h3 id="toc-1">Red Dog Casino</h3> Bitcoin casinos offer bigger winnings to players – As Bitcoin casinos have lower costs than regular online casinos, they can offer better payouts. In addition, there are Bitcoin casino no deposit bonuses! Bonuses and promotions are a way for casino sites to advertise themselves and get new players. Bitcoin is anonymous, has fast transactions, extremely low fees, and no tax issues. Bitcoin casino is the smart alternative to regular casino sites. Blackjack is probably the most recognized casino game in the world today. Our BTC Casino offer a range of video Slots, Blackjack, Roulette, Video Poker, Live Casino as well as our Exclusive games for Bitcoin gambling. If you bet $10,000 worth of BTC and win $2,000, it won’t feel like much of a win if the price of Bitcoin sinks so much that your withdrawal is only worth $5,000. If you feel you’ve been scammed, you can always request your credit card provider to perform a chargeback, allowing you to recoup your funds. They then pass on some of these savings to you in the form of frequent bonuses and promotions. Cryptocurrency helps them save money on deposit and payout fees, chargeback fees, and more. Here are some of the most commonly offered coins accepted at online casinos. A no-deposit bonus is a rare bonus offered by crypto and bitcoin casinos. Simply put, it’s a bonus that doesn’t require a deposit to be claimed. No deposit bonuses are usually much smaller than traditional welcome bonuses. This makes sense, as it doesn’t require any kind of financial commitment. Since no authority controls the market, the gaming sites don’t have to pay licensing and other fees. At the same time, Bitcoin is almost entirely anonymous, which has both pros and cons. No third party has access to your personal and financial information. Keep in mind that many online casinos, especially those that aren’t extremely crypto-friendly, will not provide this service. Many online casinos that promote their use of Bitcoin will charge a fee for selling Bitcoin for the purpose of depositing cash. To put it simply, the cryptology behind Bitcoin ensures that all Bitcoin users can enjoy anonymity on their terms. With that security in mind, you can enjoy even more security when you consider online casinos with hefty safety and privacy measures. This is exactly what you get when you play at Bitcoin.com Games. Depositing and playing at our Bitcoin casino is really easy and straightforward. Our bitcoin casino is operated by the most trusted brand in the industry.

10 Btc Betting Sites

2021-10-22T16:49:52Z

Eracornet70: Новая страница: «[https://www.inventables.com/users/borupwoods1323 http://www.goldbitcoincasino.com/] <div id="toc" style="background: #f9f9f9;border: 1px…»

[https://www.inventables.com/users/borupwoods1323 http://www.goldbitcoincasino.com/] <div id="toc" style="background: #f9f9f9;border: 1px solid #aaa;display: table;margin-bottom: 1em;padding: 1em;width: 350px;"> Content <ul class="toc_list"> <li> [#toc-0 Reason #4btc Is Better For Line Shopping] </li> <li> [#toc-1 Selecting Best Btc Sports Betting Sites For You] </li> </ul> </div> We consider BlockChain to be the best Bitcoin wallet for online gambling. However, it is important to note that it is just one of many options available. When the transaction is completed and the currency is in your account, you are just a few short steps from using BTC for online gambling. Bitcoin payouts are processed quicker than any other method. Some sites offer automatic withdrawals and players are paid in a matter of seconds. Almost all withdrawals with cryptocurrencies are processed in 24 hours or less. <ul> <li>Crypto bonuses starting from 125% to 150% are available, along with a 150% casino bonus and a flat 50% bonus on reload.</li> <li>Bitcoin only sportsbooks, because they don’t have the long history and experience of established books, don’t offer bettors the same bets and odds that traditional books do.</li> <li>You will just have to transfer them to a different wallet or exchange.</li> </ul> Every sportsbook that we recommend above not only accepts Bitcoin, but also has a long, proven history of reliability, sound financial planning, and top-notch customer service. Given their upstanding reputations, we are confident that these sportsbooks are safe options for your money and your Bitcoin. GTbets subjects Bitcoin bets, deposits, and withdrawals to the same rules as their traditional financial methods to ensure their clients’ safety and security. FortuneJack is also the best choice if you’re looking for a crypto gambling site that is dedicated to only using cryptocurrencies. With support for 9 different cryptocurrencies, and no need to verify your identity to play, FortuneJack is the go-to exchange for crypto enthusiasts who want to protect their identity. Games like Dota 2 and sports betting on sports on this website can be managed easily. This Cyprus-based company has been providing betting services for four years. It is one of the few sportsbooks to allow users a chance at preventing their losses by diversifying their bets. The operator not only offers a broad choice of sports and casino related games to wager on, but it also gives a generous deposit bonus and accepts a variety of payment methods. Its odds are likewise competitive, and participants may choose from a variety of markets. Payment methods offered by online betting with BTC are mostly digital. <h2 id="toc-0">Reason #4btc Is Better For Line Shopping</h2> Many casino sites will enable you to deposit your money with Bitcoin but later convert it to fiat currency. You can then gamble in fiat, and once you cash out the funds are then converted back to BTC. The problem with this is you do lose on exchange rates on both ends. This is why we only recommend casinos that offer pure BTC betting. Without having to deal with banks and card providers, sportsbooks save time and money on both deposits and withdrawals. Plus, if the price of Bitcoin appreciates — which it has more often than not during its history— the betting sites value goes up based on how much digital currency it owns. Their “Welcome Package” goes as high as 7 BTC (when you register just use the promo code “1xb_13206”). So if you win big and are restricted to one withdrawal a week, by the time you withdraw everything, crypto may have made it worth less than it was at the time of you winning big. If that happens, and if the crypto sportsbook you chose is trustworthy, you can relax and withdraw the maximum amount allowed each week until all your winnings are withdrawn. Once you’ve selected a platform you trust to bet with cryptocurrency, make sure it has the payout speeds and terms you need when cashing out your winnings. The website also offers an excellent sign-up bonus to new bettors, along with rollover promotions. Nitrogen Sports provides reliable odds with the best betting options for almost every sport and premier league on the planet. The player gets better privacy and a highly responsive customer support service. The platform only offers hot, online cold storage of crypto assets, which is risky. The biggest advantage of betting with Bitcoin is the higher profit margins. <h3 id="toc-1">Selecting Best Btc Sports Betting Sites For You</h3> Coinbase isn’t the ideal exchange for gamblers, and we encourage bettors to seek out other alternatives if they happen to get banned for gambling transactions. Bans often happen when users make the mistake of sending their newly purchased Bitcoins at Coinbase directly to an online betting site . Coinbase charges the same fees for selling bitcoins into US Dollars as they do for buying them from a US bank account. Converting Bitcoins back into fiat currency is done through exchanges like Coinbase, but cannot be done through wallets. However, Bitcoin is pretty close and doesn’t require bettors to reveal too much of their personal information. Once you make the deposit on the betting site, you will have to actually transfer the BTC from your wallet. The Bitcoin blockchain will process the request in a maximum of fifteen minutes, and the betting site will take it from there. Sportsbetting.ag offers the same initial welcome bonus for Bitcoin bettors. And then they continue to offer a whopping 35% on all qualifying BTC deposits thereafter. Our expert reviews the best Bitcoin gambling sites of 2021. Discover the leading trusted online Bitcoin & crypto casinos here. BetCoin AG is a company that runs one of the best live betting services in the world. The website is designed for best Bitcoin sports bettors and supports almost every main market in the live betting domain. Games and sports from many smaller markets are also available here. It’s even come to rival that of traditional betting sites, such as Coral and Betfair. Just like regular betting, these bets can be placed on anything from a game outcome, to how many points are scored in the first half. Betmaster is precisely what Indian bettors want when they search for crypto sports betting sites. This allows some of them, like 1xBit and Betcoin, to operate anonymously and accept players worldwide. If they accept players from a restricted country -- one for which they haven’t received an authorization to operate as a bookmaker -- then they might receive heavy sanctions . Such financial privacy keeps your activities hidden from your banks, credit rating agencies, and let’s be honest, your spouse/husband too, so you can bet bitcoin in peace. We’re living in a digital age that’s taking betting to the digital world too. In this guide, you’ll find everything you need to know on how to place a bet with BTC safely. Mortal Kombat X is a multi-platform fighting game by NetherRealm Studios for Xbox One, PlayStation 4, Microsoft Windows, iOS, and Android gaming platforms. From recently, gamblers from the whole world can use bitcoins for betting in this game. It combines elements of the best real-time strategy and traditional role-playing video games. Two teams, each of which has unique abilities, fight in opposition to each other in different game modes and on various maps. Given the unlimited possibility of improving the player’s skills, League of Legends cannot be won as a regular video game.

Expr

2019-03-02T11:02:36Z

Vaal: Добавил страницу "expr"

'''expr''' — команда для вычисления арифметических выражений.

== Синтаксис ==
<code bash>expr ВЫРАЖЕНИЯ</code> 
<code bash>expr OPTION</code>

== Выражения ==
Выражения состоят из аргументов отделяемых пробелами и могут принимать следующий вид:

{| class="wikitable"
| '''''Выражение''''' || '''''Результат'''''
|-
|<tt>'''arg1''' <nowiki>"|"</nowiki> '''arg2'''</tt> || <tt>'''arg1''', если он не пустой и не ''0'', в противном случае '''arg2'''</tt>
|-
|<tt>'''arg1''' <nowiki>"&"</nowiki> '''arg2'''</tt> || <tt>'''arg1''', если ни один аргумент не равен нулю или ''0'', в противном случае ''0''</tt>
|-
||<tt>'''arg1''' <nowiki>"<"</nowiki> '''arg2'''</tt> || <tt>''1'', если '''arg1''' меньше '''arg2''', в обратном случае ''0''</tt>
|-
|<tt>'''arg1''' <nowiki>"<="</nowiki> '''arg2'''</tt> || <tt>''1'', если '''arg1''' меньше или равен '''arg2''', в обратном случае ''0''</tt>
|-
|<tt>'''arg1''' <nowiki>"="</nowiki> '''arg2'''</tt> || <tt>''1'', если '''arg1''' равен '''arg2''', в обратном случае ''0''</tt>
|-
|<tt>'''arg1''' <nowiki>"!="</nowiki> '''arg2'''</tt> || <tt>''1'', если '''arg1''' не равен '''arg2''', в обратном случае ''0''</tt>
|-
|<tt>'''arg1''' <nowiki>">="</nowiki> '''arg2'''</tt> || <tt>''1'', если '''arg1''' больше или равен '''arg2''', в обратном случае ''0''</tt>
|-
|<tt>'''arg1''' <nowiki>">"</nowiki> '''arg2'''</tt> || <tt>''1'', если '''arg1''' больше '''arg2''', в обратном случае ''0''</tt>
|-
|<tt>'''arg1''' <nowiki>"+"</nowiki> '''arg2'''</tt> || <tt>Арифметическая сумма '''arg1''' и '''arg2'''</tt>
|-
|<tt>'''arg1''' <nowiki>"-"</nowiki> '''arg2'''</tt> || <tt>Арифметическая разность '''arg1''' и '''arg2'''</tt>
|-
|<tt>'''arg1''' <nowiki>"*"</nowiki> '''arg2'''</tt> || <tt>Арифметическое произведение '''arg1''' и '''arg2'''</tt>
|-
|<tt>'''arg1''' <nowiki>"/"</nowiki> '''arg2'''</tt> || <tt>Арифметическое частное от деления '''arg1''' на '''arg2'''</tt>
|-
|<tt>'''arg1''' <nowiki>"%"</nowiki> '''arg2'''</tt> || <tt>Арифметический остаток от деления '''arg1''' на '''arg2'''</tt>
|-
|<tt>'''STRING''' <nowiki>:</nowiki> '''REGEXP'''</tt> || <tt>Верно, если найдена маска '''REGEXP''' в строке '''STRING'''</tt>
|-
|<tt>match '''STRING REGEXP'''</tt> || <tt>Тоже что и '''STRING : REGEXP'''</tt>
|-
|<tt>substr '''STRING POS LENGTH'''</tt> || <tt>Подстрока из '''STRING''', первая позиция нумеруется как ''1''</tt>
|-
|<tt>index '''STRING CHARS'''</tt> || <tt>Позиция вхождения символа '''CHARS''' в строке '''STRING''', если найден, иначе ''0''</tt>
|-
|<tt>length '''STRING'''</tt> || <tt>Длина строки '''STRING'''</tt>
|-
|<tt>+ '''TOKEN'''</tt> || <tt>Интерпретировать '''TOKEN''' как строку, даже если это ключевое слово '''match''' или оператор '''/'''</tt>
|-
|<tt>'''( EXPRESSION )'''</tt> || <tt>Значение выражения '''EXPRESSION'''</tt>
|}
 
Следует помнить, что операторы должны быть '''экранированы''' или заключены в '''кавычки'''. ''Арифметическое сравнение'' допустимо только для '''чисел''', иначе сравнивается, как '''текст'''. '''Сопоставление''' с '''шаблоном''' возвращает строку между $ и $ или нуль; если $ и $ не используются, то возвращается число совпавших символов или 0.

Статус вычисления выражения устанавливается в: 
* 0, если выражение не пустое и не 0;
* 1, если выражение равно нулю или 0;
* 2, если выражение синтаксически неверно;
* 3, если произошла ошибка.

Iproute2

2018-02-28T07:13:58Z

Vaal: Новая страница: «'''iproute2''' — это набор '''утилит''' для управления параметрами сетевых устройств в ядре ''Linux'…»

'''iproute2''' — это набор '''утилит''' для управления параметрами сетевых устройств в ядре ''Linux''. Эти утилиты были разработаны в качестве унифицированного интерфейса к ядру ''Linux'', которое непосредственно управляет сетевым трафиком.

== Основные сведения ==

''iproute2'' заменил полный набор классических сетевых утилит UNIX, которые ранее использовались для настройки сетевых интерфейсов, таблиц маршрутизации и управления arp‐таблицами: [[ifconfig]], [[route]], [[ARP|arp]], [[netstat]] и других, предназначенных для создания IP‐туннелей. ''iproute2'' предлагает унифицированный синтаксис для управления самыми разными аспектами сетевых интерфейсов. Этот синтаксис во многом проще и логичнее, чем синтаксис наследованных *nix утилит, и подобен синтаксису операционной системы ''Cisco IOS'''.

Набор утилит включает в себя три основные программы:

* '''ip''' — утилита для просмотра параметров и конфигурирования сетевых интерфейсов, сетевых адресов, таблиц маршрутизации, правил маршрутизации, arp‐таблиц, IP‐туннелей, адресов multicast рассылки, маршрутизацией multicast пакетов.

* '''tc''' — утилита для просмотра и конфигурирования параметров управления трафиком (tc — аббревиатура от traffic control). Позволяет управлять классификацией трафика, дисциплинами управления очередями для различных классов трафика либо целиком для сетевого интерфейса (корневые дисциплины), что, в свою очередь, позволяет реализовать [[QoS]] в нужном для системы объёме:
** разделение разных типов трафика по классам (не только по битам [[ToS]] в [[IP‐пакет]]е, но и по другим данным из заголовка IP‐пакета)
** назначение разных дисциплин обработки очередей трафика с разным приоритетом, механизмами прохождения очереди, ограничениями по скорости и т. п.

* '''ss''' — утилита для просмотра текущих соединений и открытых портов. Аналог традиционной утилиты [[netstat]].

Автором ''iproute2'' является Алексей Кузнецов (Alexey Kuznetsov). Он разработал этот пакет, когда занимался расширением сетевых возможностей ядра Linux.

== Утилита ip ==
'''ip''' — утилита командной строки из пакета ''iproute2'' для систем ''Linux''. Она позволяет выполнять настройку сетевой подсистемы и является заменой таких утилит как: [[ifconfig]], [[route]], [[ARP|arp]]. В следующей таблице показаны предлагаемые замены.
{| class="wikitable"
|+Соответствие утилит из устаревшего пакета net-tools утилитам пакета iproute2
!Устаревшая утилита
!Заменена на
!Описание
|-
|<code>ifconfig</code>
|<code>ip addr</code>, <code>ip link</code>
|Настройка сетевого адреса, включение и выключение интерфейса
|-
|<code>route</code>
|<code>ip route</code>
|Управление таблицами маршрутизации
|-
|<code>arp</code>
|<code>ip neigh</code>
|Управление [[ARP]]-кэшем
|-
|<code>iptunnel</code>
|<code>ip tunnel</code>
|Настройка тоннелей
|-
|<code>nameif</code>
|<code>ifrename</code>
|Переименование сетевого интерфейса
|-
|<code>ipmaddr</code>
|<code>ip maddr</code>
|Настройка [[мультикаст]]-групп рассылки
|-
|<code>netstat</code>
|<code>ip -s</code>, <code>ss</code>, <code>ip route</code>
|Отображение различной сетевой статистики
|}
Для выполнения какой-либо операции после основной команды ip, указывается «объект» и команда (возможно с аргументами), которая должна быть выполнена для этого объекта.

В качестве «объектов» можно указывать следующие значения: link, addr (адреса сетевых интерфейсов), route (маршруты), rule (правила), neigh, ntable, tunnel (тоннели), maddr, mroute, monitor, xfrm. Вместо полного имени объекта можно указывать только первые буквы, если это не вызывает неоднозначность.

Можно указать команду <tt>help</tt>, для вывода подсказки. Если не указывать объект, но указать команду <tt>help</tt>, то выводится справка о программе. Если указать объект без команды, то выполняется команда <tt>show</tt> — распечатывается список объектов указанного типа.

<spoiler text="Примеры использования утилит из пакета iproute2 ">
{| class="wikitable collapsible"
|-
! Команда
! Комментарий
|-
| '''<tt>ip help</tt>'''
| Вывод общей справки
|-
| '''<tt>ip a h</tt>'''
<pre>Usage: ip addr {add|change|replace} IFADDR dev STRING [ LIFETIME ]
[ CONFFLAG-LIST]
ip addr del IFADDR dev STRING
ip addr {show|flush} [ dev STRING ] [ scope SCOPE-ID ]
[ to PREFIX ] [ FLAG-LIST ] [ label PATTERN ]
IFADDR := PREFIX | ADDR peer PREFIX
[ broadcast ADDR ] [ anycast ADDR ]
[ label STRING ] [ scope SCOPE-ID ]
SCOPE-ID := [ host | link | global | NUMBER ]
FLAG-LIST := [ FLAG-LIST ] FLAG
FLAG := [ permanent | dynamic | secondary | primary |
tentative | deprecated | CONFFLAG-LIST ]
CONFFLAG-LIST := [ CONFFLAG-LIST ] CONFFLAG
CONFFLAG := [ home | nodad ]
LIFETIME := [ valid_lft LFT ] [ preferred_lft LFT ]
LFT := forever | SECONDS
</pre>
| Распечатка подсказки — команд и их аргументов для объекта addr. '''Заметьте, что вместо слов addr и help указаны сокращения.'''
|-
| '''<tt>ip a</tt>''' 
<pre>
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 16436 qdisc noqueue
link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
inet 127.0.0.1/8 brd 127.255.255.255 scope host lo
inet6 ::1/128 scope host
valid_lft forever preferred_lft forever
2: eth1: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast qlen 1000
link/ether 00:16:17:eb:a9:da brd ff:ff:ff:ff:ff:ff
inet 172.22.2.1/16 brd 172.22.255.255 scope global eth1
inet6 fe80::216:17ff:feeb:a9da/64 scope link
valid_lft forever preferred_lft forever
3: eth2: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast qlen 1000
link/ether 00:16:17:eb:d3:20 brd ff:ff:ff:ff:ff:ff
inet 10.19.121.211/22 brd 10.19.123.255 scope global eth2
inet6 fe80::216:17ff:feeb:d320/64 scope link
valid_lft forever preferred_lft forever
5: ppp0: <POINTOPOINT,MULTICAST,NOARP,UP,LOWER_UP> mtu 1492 qdisc pfifo_fast qlen 3
link/ppp
inet 89.37.48.117 peer 81.9.101.117/32 scope global ppp0</pre>
| Распечатка всех (физических и виртуальных интерфейсов). Для сравнения приводится информацией, выводимая командой <tt>ifconfig -a</tt>
<pre>eth1 Link encap:Ethernet HWaddr 00:16:17:EB:A9:DA
inet addr:172.22.2.1 Bcast:172.22.255.255 Mask:255.255.0.0
inet6 addr: fe80::216:17ff:feeb:a9da/64 Scope:Link
UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1
RX packets:13444859 errors:0 dropped:0 overruns:0 frame:0
TX packets:7073798 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:1000
RX bytes:2540456241 (2422.7 Mb) TX bytes:916670636 (874.2 Mb)
Interrupt:16 Base address:0x2000

eth2 Link encap:Ethernet HWaddr 00:16:17:EB:D3:20
inet addr:10.19.121.211 Bcast:10.19.123.255 Mask:255.255.252.0
inet6 addr: fe80::216:17ff:feeb:d320/64 Scope:Link
UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1
RX packets:266115675 errors:0 dropped:0 overruns:0 frame:0
TX packets:409606457 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:1000
RX bytes:294857473 (281.1 Mb) TX bytes:109522306 (104.4 Mb)
Interrupt:17 Base address:0x4000

lo Link encap:Local Loopback
inet addr:127.0.0.1 Mask:255.0.0.0
inet6 addr: ::1/128 Scope:Host
UP LOOPBACK RUNNING MTU:16436 Metric:1
RX packets:3480203 errors:0 dropped:0 overruns:0 frame:0
TX packets:3480203 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:0
RX bytes:1531400801 (1460.4 Mb) TX bytes:1531400801 (1460.4 Mb)

ppp0 Link encap:Point-to-Point Protocol
inet addr:89.37.48.117 P-t-P:81.9.101.117 Mask:255.255.255.255
UP POINTOPOINT RUNNING NOARP MULTICAST MTU:1492 Metric:1
RX packets:46940444 errors:0 dropped:0 overruns:0 frame:0
TX packets:66480329 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:3
RX bytes:3859205550 (3680.4 Mb) TX bytes:1343026828 (1280.8 Mb)</pre>
|-
| '''<tt>ip link</tt>'''
<pre>1: lo: <LOOPBACK,UP,LOWER_UP> mtu 16436 qdisc noqueue state UNKNOWN
link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP qlen 1000
link/ether 00:16:d4:b3:68:de brd ff:ff:ff:ff:ff:ff</pre>
| Вывод информации об интерфейсах. Напоминает данные, выводимые об адресах, но намного короче, так как указываются только [[MAC-адрес|физические адреса]] интерфейсов и не выводятся логические [[IP]]/[[IPv6]].
|-
| '''<tt>ip rou</tt>'''<pre>81.9.101.117 dev ppp0 proto kernel scope link src 89.37.48.117
10.19.120.0/22 dev eth2 proto kernel scope link src 10.19.121.211
172.22.0.0/16 dev eth1 proto kernel scope link src 172.22.2.1
127.0.0.0/8 dev lo scope link
default via 81.9.101.117 dev ppp0
</pre>
| Список сетевых маршрутов.
|-
| '''<tt>ip ro flush cache</tt>'''
| Очистка кэша маршрутов.
|-
| '''<tt>ip ro add 81.9.100.12 via 89.37.48.117 dev ppp0</tt>'''
| Добавление нового маршрута.
|-
| '''<tt>ip ru</tt>'''<pre>0: from all lookup local
32764: from 192.168.72.115 lookup co-tbl
32765: from 89.37.48.117 lookup zet-tbl
32766: from all lookup main
32767: from all lookup default</pre>
| Распечатка правил маршрутизации. Заметьте что в данном случае используются несколько таблиц маршрутизации.
|-
| '''<tt>ip t</tt>''' 
<tt>tunl0: ip/ip remote any local any ttl inherit nopmtudisc
</tt> 
<tt>gre0: gre/ip remote any local any ttl inherit nopmtudisc</tt> 
<tt>sit0: ipv6/ip remote any local any ttl 64 nopmtudisc</tt>
| Распечатка списка тоннелей.
|}
</spoiler>
== Ссылки ==
* [https://web.archive.org/web/20140623231840/http://www.linuxfoundation.org/collaborate/workgroups/networking/iproute2 Текущий официальный сайт]
* [http://ubuntologia.ru/forum/viewtopic.php?f=109&t=2300 Продолжение по мотивам статьи для системных администраторов старой закалки, которая поможет перейти на ''iproute2'' с legacy-утилит]
* [https://habrahabr.ru/post/320278/ Тяжелое расставание с Net-Tools, Хабрахабр, Микаел temujin Григорян]

Ifconfig

2018-02-28T06:59:24Z

Vaal: Новая страница: «'''ifconfig''' (сокр. '''i'''nter'''f'''ace '''config'''uration) — команда UNIXи UNIX‐подобных операционных систем. ==…»

'''ifconfig''' (сокр. '''i'''nter'''f'''ace '''config'''uration) — команда UNIXи UNIX‐подобных операционных систем.

== Синтаксис ==
ifconfig [interface]
ifconfig interface [aftype] options | address ...

== Описание ==
Команда <tt>ifconfig</tt> - аналог '''ipconfig''' Windows, с другими ключевыми параметрами и ''более широким функционалом''. Используется для назначения сетевого адреса, изменения настроек параметров сетевого адаптера и ''IP'' протокола. Она используется в большинстве ''*nix'' систем на этапе загрузки операционной системы для настройки сетевых интерфейсов. После этого она обычно используется только при отладке, настройке или восстановлении системы.

При вызове '''''man ifconfig''''' (для '''FreeBSD''') — выводится полное руководство о параметрах команды.

Если аргументы не переданы, <tt>ifconfig</tt> выдаёт информацию о состоянии активных интерфейсов. Если указан один аргумент — '''интерфейс''', выдаётся информация только о состоянии этого '''интерфейса'''; если указан один аргумент <tt>-a</tt>, выдаётся информация о состоянии всех '''интерфейсов''', даже отключенных. Иначе команда конфигурирует указанный '''интерфейс'''.

В современных дистрибутивах ''Linux'' утилита <tt>ifconfig</tt> считается устаревшей и заменена утилитой [[iproute2]], основные функции настроек сетевого '''интерфейса''' получила утилита ip из состава [[iproute2]]. Для ''Unix'' систем не потеряло актуальности.

== Семейство протоколов ==
Если первым после имени интерфейса идёт имя поддерживаемого семейства адресов, это семейство адресов используется для декодирования и выдачи всех адресов протокола. В настоящее время поддерживаются семейства адресов inet (TCP/IP, используется по умолчанию), inet6 (IPv6), ax25 (AMPR Packet Radio), ddp (Appletalk Phase 2), ipx (Novell [[IPX]]) и netrom (AMPR Packet Radio).

== Опции ==

{| align="center" class="standard"
|+
|-----
! |Опция
! |Описание
|-----
| '''interface'''
| ''Имя интерфейса. Обычно это имя драйвера, за которым идет номер устройства, например, eth0 для первого интерфейса Ethernet.''
|-----
| '''up'''
| ''Помечает интерфейс как включенный. Это можно использовать для включения интерфейса после ifconfig down. Это происходит автоматически при установке первого адреса интерфейса. Если интерфейс был переустановлен при предыдущей пометке в качестве отключенного, аппаратное обеспечение будет переинициализировано.''
|-----
| '''down'''
| ''Помечает интерфейс как отключенный. Когда интерфейс помечен как отключенный, система не пытается пересылать сообщения через этот интерфейс. При возможности, интерфейс будет переустановлен, чтобы отключить также прием. Это действие не отключает автоматически маршруты, использующие данный интерфейс.''
|-----
| '''arp'''
| ''Включает использование протокола разрешения адреса ([[ARP|Address Resolution Protocol]]) при сопоставлении адресов на уровне сети и адресов на уровне связи (используется по умолчанию). В настоящее время это реализуется путём сопоставления адресов DARPA Internet и адресов Ethernet 10 Мбит/с.''
|-----
| '''-arp'''
| ''Отключает использование протокола разрешения адреса ([[ARP|Address Resolution Protocol]]).''
|-----
| '''promisc'''
| ''Помещает интерфейс в состояние promiscuous. В широковещательной сети это заставляет интерфейс получать все пакеты независимо от того, были ли они предназначены для этой машины или нет. Это позволяет, используя фильтры пакетов, анализировать сетевой трафик. Обычно, это хорошая техника охоты на сетевые проблемы, которые иначе трудно отловить. Здесь весьма полезна утилита [[tcpdump]]. С другой стороны, это позволяет хакерам исследовать движение паролей по сети и делать другие черные дела. Одна защита против этого типа нападения: не позволять присоединяться к сети чужим компьютерам. Другой способ: использовать безопасные опознавательные протоколы, типа Kerberos, или SRA login. Эта опция соответствует флагу PROMISC.''
|-----
| '''-promisc'''
| ''Запрещает режим promiscuous.''
|-----
| '''allmulti'''
| ''Включает или отключает режим all-multicast. В этом режиме все многоадресные (multicast) пакеты в сети будут приниматься этим интерфейсом.''
|-----
| '''-allmulti'''
| ''Отключает режим all-multicast.''
|-----
| '''metric N'''
| ''Устанавливает стоимость маршрутизации для интерфейса равной n, вместо стандартного значения 0. Стоимость маршрутизации (routing metric) используется протоколом маршрутизации (см. [[routed]]). Большие стоимости делают маршрут менее предпочтительным; стоимости учитываются как дополнительные пересылки на пути к целей сети или хосту.''
|-----
| '''mtu N'''
| ''Этот параметр устанавливает максимальный размер пакета ([[maximum transmission unit]] — MTU) для интерфейса. Обычно нет необходимости менять значение этого параметра, но, в некоторых случаях, уменьшение значения MTU позволяет добиться устойчивой работы абонентов с очень низким уровнем сигнала. Кроме того, он может использоваться для изменения параметров туннельных интерфейсов.''
|-----
| '''dstaddr addr'''
| ''Устанавливает удаленный IP-адрес для двухточечной связи (например, по протоколу [[PPP (сетевой протокол)|PPP]]). Это ключевое слово сейчас считается устаревшим; используйте вместо него ключевое слово pointopoint.''
|-----
| '''netmask addr'''
| ''Устанавливает маску сети IP для этого интерфейса. По умолчанию используется обычная маска сети класса A, B или C (что определяется по IP-адресу интерфейса), но можно установить любое значение.''
|-----
| '''add addr/prefixlen'''
| ''Добавляет адрес IPv6 для интерфейса.''
|-----
| '''del addr/prefixlen'''
| ''Удаляет адрес IPv6 для интерфейса.''
|-----
| '''tunnel aa.bb.cc.dd'''
| ''Создаёт новое устройство SIT (IPv6-в-IPv4) — тоннель к указанной цели.''
|-----
| '''irq'''
| ''Устанавливает аппаратное прерывание, используемое данным устройством. Не для всех устройств можно динамически менять значение IRQ.''
|-----
| '''io_addr addr'''
| ''Устанавливает адрес начала области ввода-вывода для данного устройства.''
|-----
| '''mem_start addr'''
| ''Устанавливает адрес начала области разделяемой памяти, используемой этим устройством. Это нужно лишь для немногих устройств.''
|-----
| '''media type'''
| ''Устанавливает физический порт или тип носителя, используемый устройством. Не для всех устройств можно менять этот параметр, и для разных устройств могут поддерживаться различные значения. Типичные значения типа — [[10base2]] (коаксиальный кабель Ethernet), [[10baseT]] (витая пара Ethernet 10 Мбит/сек), [[AUI]] (внешний передатчик) и т. д. Специальный тип носителя auto можно использовать, чтобы потребовать от драйвера автоматически определять тип носителя. Не все драйверы могут это делать.''
|-----
| '''bootproto [[static][dhcp]]'''
| ''Устанавливает способ получения IP адреса.
(статический, которые описывается Вами, либо динамический получаемый от DHCP-сервера)''
|-----
| '''broadcast [addr]'''
| ''Устанавливает широковещательный адрес. Широковещательный адрес обычно создается из сетевого адреса установкой всех бит части машины. Некоторые реализации IP используют другую схему, эта опция помогает приспособиться к этим странным средам. Если широковещательный (broadcast) адрес был установлен, ifconfig показывает флаг BROADCAST .''
|-----
| '''pointopoint [addr]'''
| ''Это ключевое слово включает двухточечный (point-to-point) режим интерфейса, означающий, что он обеспечивает непосредственную связь между двумя машинами, которую никто не прослушивает. Если указан также аргумент адрес, устанавливает соответствующий протоколу адрес другой стороны связи, как и устаревшее ключевое слово dstaddr. В противном случае, устанавливает или сбрасывает флаг IFF_POINTOPOINT для интерфейса.''
|-----
| '''-pointopoint [addr]'''
| ''Это ключевое слово отключает двухточечный (point-to-point) режим интерфейса.''
|-----
| '''hw class address'''
| ''Устанавливает аппаратный адрес соответствующего интерфейса, если драйвер устройства поддерживает такую возможность. После ключевого слова hw необходимо указать имя класса оборудования, а также аппаратный адрес в текстовом виде. В настоящее время поддерживается оборудование классов ether (Ethernet), ax25 (AMPR AX.25), ARCnet и netrom (AMPR NET/ROM).''
|-----
| '''multicast'''
| ''Устанавливает у интерфейса флаг поддержки групповой передачи данных. Обычно в этом нет нужды, поскольку драйвер сам выставляет этот флаг.''
|-----
| '''address'''
| ''IP-адрес, присваиваемый интерфейсу.''
|-----
| '''txqueuelen length'''
| ''Устанавливает длину очереди передачи для устройства. Это позволяет установить меньшие значения для более медленных устройств с продолжительными задержками (модемные линии, ISDN), чтобы быстрая передача больших объёмов данных не слишком мешала передаче данных интерактивных сеансов, например, telnet.''
|+
|}

== Примеры ==

# ifconfig eth0 inet 192.168.10.15 netmask 255.255.255.0
# ifconfig eth0 up
# ifconfig
eth0 Link encap:Ethernet HWaddr 00:18:F3:BE:18:1E
inet addr:192.168.10.15 Bcast:192.168.10.255 Mask:255.255.255.0
inet6 addr: fe80::218:f3ff:febe:181e/64 Scope:Link
UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1
RX packets:39456 errors:0 dropped:0 overruns:0 frame:0
TX packets:45730 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:1000
RX bytes:25457904 (24.2 Mb) TX bytes:6540945 (6.2 Mb)
Interrupt:20

lo Link encap:Local Loopback
inet addr:127.0.0.1 Mask:255.0.0.0
inet6 addr: ::1/128 Scope:Host
UP LOOPBACK RUNNING MTU:16436 Metric:1
RX packets:182 errors:0 dropped:0 overruns:0 frame:0
TX packets:182 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:0
RX bytes:12812 (12.5 Kb) TX bytes:12812 (12.5 Kb)

#

== См. также ==
* [[netstat]]
* [[iptables]]

== Ссылки ==
[http://semenushkin.ru/2010/09/28/ifconfig-alias/ Дополнительный ip для интерфейса (ifconfig alias)]

Bash-task

2018-02-19T17:45:34Z

Vaal:

На данной странице представлены задачи и примерные решения на bash(актуально для RHEL 7.x/CentOS 7.x. В других случаях требуется проверка). 
'''''Задача №1'''''
'''Используя цикл и оператор выбора написать скрипт, реализующий следующее''':
* Выводит на экран(в терминал) '''меню с выбором''', состоящим из двух пунктов "''1)''" "''2)''"
* При выборе "''1)''" выводит текст на экран(в терминал), содержащий только цифру '''1'''
* При выборе "''2)''" выводит текст на экран(в терминал), содержащий только цифру '''2'''
* При вводе любого другого символа, выводит на экран сообщение о неправильном вводе и просит повторить ввод.
При неправильном вводе цикл бесконечен, т.е. продолжается пока не будет введён нужный символ, а затем снова выводится меню выбора.
'''Модернизировать'''(№1) скрипт так, чтобы при ''неправильном вводе'' он выводил сообщение о выходе из скрипта через ''три секунды'', после трёх секунд ожидания осуществляется выход из скрипта. '''Модернизировать'''(№2) скрипт добавив в него возможность прекращения работы в меню.

<spoiler text="Вариант решения Задачи №1"><source lang="bash">
#!/bin/env bash
#trap 'echo -e "\e[31mВот фиг тебе, а не прерывание\e[0m!"' 1 2 3 5 9 15
PS3='Введите значение: ' && echo

while :
do
#clear
options=("1" "2")
#options=("1" "2" "Завершение работы скрипта") — для модернизации №2
select opt in "${options[@]}"; do
case "$opt" in
1) echo 'Ввели ' "$opt"
break 1
;;
2) echo 'Ввели ' "$opt"
break 1
;;
# Для модернизации №2:
#'Завершение работы скрипта')
# echo "Завершили работу скрипта"
# exit
;;
*) echo 'Ввели неверный символ'
echo 'Повторите ввод'
break 1
#echo "Прекращаем работу скрипта через 3 секунды и осуществляем выход" — для модернизации №1
#sleep 3; exit 0 — для модернизации №1
;;
esac
#break
done
done
</source>
</spoiler>

'''''Задача №2'''''
'''Написать скрипт реализующий следующее''':
* Создать '''функцию''', которая реализует ''вывод списка директорий'' в файл '''/tmp/dir_list.log'''. При этом в качестве ''входного аргумента'' для функции служит переданный скрипту параметр, представляющий из себя ''абсолютный путь''.
* Создать '''функцию''', которая будет ''считывать содержимое'' '''/tmp/dir_list.log''' и выводить на экран, а также копировать это содержимое в '''/tmp/dir_list.0'''.
* Вызов функций происходит с ''задержкой в 5 секунд''.
* После успешной отработки скрипта и выхода из него файлы '''/tmp/dir_list.log''' и '''/tmp/dir_list.0''' должны быть автоматически удалены. Для этого пункта '''запрещается''' прямой вызов ''`rm -rf`'' или ''$(rm -rf)'' перед завершением скрипта.
<spoiler text="Подсказки для задачи №2"><source lang="bash">
find . -maxdepth 1 -type d -printf '%f\n' — выводит все директории
find . -maxdepth 1 -type d| sed 's|./*||' | sed '/^$/d' — выводит все директории
find . -maxdepth 1 -type d -printf '%f\n'|sed '1d' — выводит все директории, кроме первой(в ней размещается ".")
ls -l|grep 'drwx'| awk '{print $9}'
for i in *; do [ -d "$i" ] && echo "$i";done
ls -d */ | sed 's|\/||g'
find * -maxdepth 0 -type d
</spoiler>

<spoiler text="Вариант решения Задачи №2"><source lang="bash">
#!/bin/env bash
_find_dir=$1
log="/tmp/dir_list.log"
log_0="/tmp/dir_list.0"

trap "rm -rf $log $log_0" EXIT

find_dir (){
find $_find_dir -maxdepth 1 -type d -printf '%f\n'|sed '1d' >> $log
#find $_find_dir -maxdepth 0 -type d >> $log
#ls -l $_find_dir|grep 'drwx'| awk '{print $9}'>> $log
#cd $_find_dir;for i in *; do [ -d "$i" ] && echo "$i";done >> $log
}

cp_list (){
cat $log|tee -a $log_0
}

find_dir
sleep 5
cp_list
exit 0
</source>
</spoiler>

'''''Задача №3'''''
'''Написать скрипт, который передаёт всю полученную в ходе своей работы информацию в системный журнал''':
* ''Дату и время'' в формате ''ГГГГ-ММ-ДД_ЧЧ-ММ-СС''.
* ''Список'' зарегистрировавшихся в системе,на ''текущий момент'', пользователей.
* ''Время'' работы системы(вывод должен быть представлен ''кириллицей'').
В консоли продемонстрировать вывод верно работающего скрипта.

<spoiler text="Вариант решения Задачи №3"><source lang="bash">
#!/bin/env bash
reg_u=$(who |awk {'print $1'})
xdate=$(date +%Y-%m-%d_%H-%M-%S)
upt=$(uptime -p |sed -e 's|up||g' -e 's|day.|дня(-ей)|' -e 's|hour.|час(-а,-ов)|' -e 's|minute.|минут(-ы)|')
upt_w=$(uptime -p |sed -e 's|up||g' -e 's|week.|недель(-я,-и)|' -e 's|day.|дня(-ь,-ей)|' -e 's|hour.|час(-а,-ов)|' -e's|minute.|минут(-ы)|')

log_sys(){
logger -i -t "CSys" Дата\/время: $xdate \| Зарегистрированные в системе пользователи: $reg_u \| Время работы системы: $1
}

if [ $(uptime|awk {'print $3'}) -gt 7 ]; then log_sys "$upt_w"; else log_sys "$upt"; fi

exit 0
</source>
</spoiler>

'''''Задача №4'''''
'''Написать bash скрипт, который будет принимать в себя аргумент и, если значение, которое он принял будет чётное, то скрипт будет печатать только чётные значения до этого числа, если значение аргумента нечётное число, то печатать только нечётные значения до этого числа. В конце работы скрипт должен вывести сколько чётных или нечётных значений до этого числа.'''

<spoiler text="Первый вариант решения Задачи №4"><source lang="bash">
#!/bin/env bash

export chislo=$1

if [[ $chislo =~ [a-zA-Z] ]]; then
echo -e "\e[31mВвели не число\e[0m!"

elif [[ $chislo -eq 0 ]]; then
echo -e "Ввели число \e[31m0\e[0m"
echo -e "Количество \e[32mчётных\e[0m элементов в числе \e[31m0\e[0m равно \e[31m1\e[0m"

elif [[ ($chislo -gt 0) && ($(($chislo % 2)) -eq 0) ]]; then
even_chislo=$(seq 2 2 $chislo)
echo "Все чётные числа входящие в $chislo:"
for i in $even_chislo
do
echo $i
new_chislo=( "${new_chislo[@]}" "$i" )
done
echo -e "Количество \e[32mчётных\e[0m элементов в числе \e[32m$chislo\e[0m равно \e[31m${#new_chislo[@]}\e[0m"
elif [[ ($chislo -gt 0) && ($(($chislo % 2)) -eq 1) ]]; then
odd_chislo=$(seq 1 2 $chislo)
echo "Все нечётные числа входящие в $chislo:"
for i in $odd_chislo
do
echo $i
new_chislo=( "${new_chislo[@]}" "$i" )
done
echo -e "Количество \e[31mнечётных\e[0m элементов в числе \e[31m$chislo\e[0m равно \e[32m${#new_chislo[@]}\e[0m"

elif [[ ($chislo -lt 0) && ($(($(echo $chislo | sed 's|^-||g') % 2)) -eq 0) ]]; then
echo "Все чётные числа входящие в $chislo:"
chislo=$(echo $chislo | sed 's|^-||g')
even_chislo=$(seq 2 2 $chislo)
for i in $even_chislo
do
echo "-$i"
new_chislo=( "${new_chislo[@]}" "$i" )
done
echo -e "Количество отрицательных \e[32mчётных\e[0m элементов в числе \e[32m-$chislo\e[0m равно \e[31m${#new_chislo[@]}\e[0m"

elif [[ ($chislo -lt 0) && ($(($(echo $chislo | sed 's|^-||g') % 2)) -eq 1) ]]; then
echo "Все нечётные числа входящие в $chislo:"
chislo=$(echo $chislo | sed 's|^-||g')
odd_chislo=$(seq 1 2 $chislo)
#echo "Все нечётные числа входящие в $chislo:"
for i in $odd_chislo
do
echo "-$i"
new_chislo=( "${new_chislo[@]}" "$i" )
done
echo -e "Количество отрицательных \e[31mнечётных\e[0m элементов в числе \e[31m-$chislo\e[0m равно \e[32m${#new_chislo[@]}\e[0m"

fi
</source>
</spoiler>



<spoiler text="Второй вариант решения Задачи №4"><source lang="bash">
#!/bin/env bash
num=$1
if [[ $num =~ - ]]; then
printf "Требуется передать в скрипт целое ПОЛОЖИТЕЛЬНОЕ число\n"
exit 1
elif [[ "`expr $num % 2`" == 0 ]]; then
for ((i=1; i<=$num; i++)); do
if [[ "`expr $i % 2`" == 0 ]]; then
echo "$i"
((chet+=1))
else
((nchet+=1))
fi
done
elif [[ "`expr $num % 2`" == 1 ]]; then
for ((i=1; i<=$num; i++)); do
if [[ "`expr $i % 2`" == 0 ]]; then
((chet+=1))
else
echo "$i"
((nchet+=1))
fi
done
else
printf "Требуется передать в скрипт целое ПОЛОЖИТЕЛЬНОЕ число\n"
exit 1
fi
printf "Количество четных чисел %d \nКоличество нечетных чисел %d \n" "$chet" "$nchet"
</source>
</spoiler>



<spoiler text="Третий вариант решения Задачи №4"><source lang="bash">
#!/bin/env bash
num=$1
i=1
if [[ $num =~ - ]]; then
printf "Требуется передать в скрипт целое ПОЛОЖИТЕЛЬНОЕ число\n"
exit 1
elif [[ "`expr $num % 2`" == 0 ]]; then
while (($i<=$num)); do
if [[ "`expr $i % 2`" == 0 ]]; then
echo "$i"
((chet+=1))
else
((nchet+=1))
fi
((i+=1))
done
elif [[ "`expr $num % 2`" == 1 ]]; then
while (($i<=$num)); do
if [[ "`expr $i % 2`" == 0 ]]; then
((chet+=1))
else
echo "$i"
((nchet+=1))
fi
((i+=1))
done
else
printf "Требуется передать в скрипт целое ПОЛОЖИТЕЛЬНОЕ число\n"
exit 1
fi
printf "Количество четных чисел %d \nКоличесвто нечетных чисел %d \n" "$chet" "$nchet"
</source>
</spoiler>

Ps

2018-02-07T10:14:28Z

Vaal: Новая страница: «'''ps''' (от англ. '''p'''rocess '''s'''tatus) — программа в UNIX, Unix-подобных и других POSIX-совместимых опер…»

'''ps''' (от англ. '''p'''rocess '''s'''tatus) — программа в UNIX, Unix-подобных и других POSIX-совместимых операционных системах, выводящая отчёт о работающих процессах.

== Синтаксис ==
<pre>
ps [опции]
</pre>

* Опции, отбирающие процессы для отчёта:
** -A : все процессы;
** -a : связанные с конкретным терминалом, кроме главных системных процессов сеанса, часто используемая опция;
** -N : отрицание выбора;
** -d : все процессы, кроме главных системных процессов сеанса;
** -e : все процессы;
** -f : расширение информации
** T : все процессы на конкретном терминале;
** a : процессы, связанные с текущим терминалом, а также процессы других пользователей;
** r : информация только о работающих процессах;
* x : процессы, отсоединённые от терминала.

== Выводимая информация ==
Столбцы:
* UID : идентификатор пользователя;
* PID : идентификатор процесса;
* PPID : идентификатор родительского процесса;
* C : приоритет процесса, используемый планировщиком задач;
* STIME : время старта процесса;
* TTY : терминал, с которым связан данный процесс;
* TIME : процессорное время, занятое этим процессом;
* CMD : команда, запустившая данный процесс «с некоторыми опциями выводит и каталог откуда процесс был запущен»;
* STAT : состояние, в котором на данный момент находится процесс.

Опция '''''o''''' позволяет указать набор столбцов в ответе:
ps o pid,user,command

== Параметры STAT ==

* R : процесс выполняется в данный момент
* S : процесс ожидает (т.е. спит менее 20 секунд)
* I : процесс бездействует (т.е. спит больше 20 секунд)
* D : процесс ожидает ввода-вывода (или другого недолгого события), непрерываемый
* Z : zombie или defunct процесс, то есть завершившийся процесс, код возврата которого пока не считан родителем
* T : процесс остановлен
* W : процесс в свопе
* < : процесс в приоритетном режиме.
* N : процесс в режиме низкого приоритета
* L : real-time процесс, имеются страницы, заблокированные в памяти.
* s : лидер сессии

== Примеры использования ==
# ps
PID TTY TIME CMD
2643 pts/0 00:00:00 su
2644 pts/0 00:00:00 bash
3092 pts/0 00:00:00 ps

# ps ax
PID TTY STAT TIME COMMAND
1 ? S 0:01 init [3]
2 ? SN 0:00 [ksoftirqd/0]
3 ? S< 0:00 [events/0]
4 ? S< 0:00 [khelper]
5 ? S< 0:00 [kblockd/0]
29 ? S 0:00 [pdflush]

# ps af
PID TTY STAT TIME COMMAND
2617 pts/0 Ss 0:00 -bash
2643 pts/0 S 0:00 \_ su -
2644 pts/0 S 0:00 \_ -bash
3100 pts/0 R+ 0:00 \_ ps af
2176 tty6 Ss+ 0:00 /sbin/mingetty tty6
2175 tty5 Ss+ 0:00 /sbin/mingetty tty5

== Примечания ==
* Альтернативой <tt>ps</tt> является команда <tt>[[top]]</tt>, удобно выводящая на экран постоянно обновляющуюся информацию, однако <tt>top</tt> ограничена размерами окна, поэтому всё, что не может поместиться на экран, просто игнорируется.
* Для команды <tt>ps</tt> удобно пользоваться конвейером и утилитой [[less]] для пролистывания выводимой информации с помощью кнопок вверх и вниз, например <code>ps ax | less</code>
* С помощью утилиты [[grep]] удобно искать и выводить только нужные процессы, например <code>ps ax | grep smbd</code>
* В связи с возможностью написания модуля, подгружаемого к ядру, и возвращающего на запрос от <tt>ps</tt> ''модифицированный'' список процессов, администраторам не рекомендуется всецело полагаться на результаты <tt>ps</tt> и <tt>top</tt> при подозрениях на возможность несанкционированного вмешательства.

== Ссылки ==
* [http://www.opengroup.org/onlinepubs/009695399/utilities/ps.html Спецификация ps в Единой спецификации UNIX на сайте The Open Group]
* [https://en.wikipedia.org/wiki/Ps_(Unix) Ссылка на англ. страницу Wiki]
* [https://www.opennet.ru/man.shtml?topic=ps&category=1&russian=5 MAN на OpenNET]

Sort

2018-01-10T10:29:47Z

Vaal: Добавлено описание команды sort

'''sort''' — Команда сортировки и/или слияния файлов. 

== Синтаксис ==
'''sort''' ['''''-c'''''] ['''''-m'''''] ['''''-u'''''] ['''''-o выходной_файл'''''] ['''''-y'''''килобайт] ['''''-z'''''длина] 
:['''''-d'''''] ['''''-f'''''] ['''''-i'''''] ['''''-M'''''] ['''''-n'''''] ['''''-r'''''] ['''''-b'''''] ['''''-t'''''разделитель] 
:['''''+позиция_1''''' ['''''-позиция_2''''']] ['''''файл ...'''''] 

== Описание ==
Команда [[sort]] сортирует строки, входящие во все исходные файлы, и выдаёт результат на стандартный вывод. Если имена файлов не указаны, или в качестве файла указан -, исходная информация поступает со стандартного ввода. При упорядочении используется один или несколько ключей сортировки, выделяемых из каждой вводимой строки. По умолчанию ключ сортировки один – вся строка, а порядок является лексикографическим, соответствующим принятой кодировке символов.
;Основные параметры<nowiki>:</nowiki>

''Обязательные аргументы для длинных форм параметров являются также обязательными и для коротких форм''.
;-b, --ignore-leading-blanks
: игнорировать пробелы в начале сортируемых полей или начале ключей
;-d, --dictionary-order
: воспринимать в составе ключей лишь буквы (латинского алфавита), цифры и пробелы, игнорируя все прочие символы
;-f, --ignore-case
: во время сортировки преобразует строчные (маленькие) в соответствующие прописные (большие) буквы, т.е. выполняется сортировка нечувствительная к регистру символов
;-g, --general-numeric-sort
: выполнять сравнение в соответствии с общим числовым значением (используют совместно с параметром -b). Это численная сортировка, при которой дополнительно распознаётся экспоненциальное представление чисел (например, 9.1019e7)
;-i, --ignore-nonprinting
: в ключах рассматриваются только печатаемые (ASCII) символы, а остальные игнорируются
;-M, --month-sort
: выполнять сравнение по трёх-символьным сокращениям англоязычных названий месяцев, т.е. (незнакомое) < `JAN' < ... < `DEC'
;-n, --numeric-sort
: числовая сортировка, т.е. сравнение ведётся по числовому значению (используют совместно с параметром -b)
;-r, --reverse
: сортировка выполняется в обратном порядке (по убыванию)
;-y''килобайт''
: количество дополнительной памяти, используемой командой [[sort]], существенно влияет на скорость её работы. Если опция ''-y'' отсутствует, [[sort]] начинает работу, используя область памяти некоторого стандартного размера, а в случае необходимости запрашивает дополнительную память. Если опция ''-y'' задана с аргументом, команда [[sort]] начинает работу, используя указанное число килобайт памяти, если только не нарушены ограничения сверху или снизу; в этом случае используется соответствующее крайнее значение. Таким образом, указание ''-y0'' гарантирует использование минимального объема памяти. Опция ''-y'' без аргумента задаёт область памяти максимального размера.
;-zдлина
: во время сортировки запоминается размер самой длинной строки, так что для фазы слияния команда [[sort]] может отвести буфер нужного размера. Если, в силу действия опций ''-c'' или ''-m'', фаза сортировки пропускается, используется некоторый стандартный размер. Наличие строк, превышающих по длине буфер, приводит к аварийному завершению команды. Задание заведомо достаточной длины гарантирует нормальное выполнение слияния.

;Другие параметры:

;-c, --check
: проверяет сортировался ли указанный файл. Если да, то не выполняет сортировку, иначе выводит сообщение об ошибке
;-k, --key=ПОЗ1[,ПОЗ2]
:выбирает ключ сортировки, начиная с позиции ''ПОЗ1'' и заканчивая позицией ''ПОЗ2'' (включительно). Номера полей и смещения символов указываются, начиная с 1
;-m, --merge
: объединяет ранее отсортированные ФАЙЛЫ, которые не сортируются повторно
;-o, --output=ФАЙЛ
: выводит результат в указанный файл ФАЙЛ вместо стандартного вывода
;-s, --stable
: стабилизирует сортировку, не выполняя сравнения последней пересортировки
;-S, --buffer-size=РАЗМЕР
: под основной буфер в памяти использует область размером РАЗМЕР
;-t, --field-separator=СИМВОЛ
: использовать СИМВОЛ в качестве разделителя полей
;-T, --temporary-directory=КАТАЛОГ
: использует указанный КАТАЛОГ для временных файлов, игнорируя переменную окружения $TMPDIR или /tmp; составные параметры могут указывать на различные каталоги
;-u, --unique
: уникальная сортировка: игнорирует повторяющиеся строки. Обычно применяют с параметром ''-c'' для проверки сортированных файлов с целью прерывания выполнения, если встретится несколько одинаковых строк подряд; без -c выводится только первая строка из одинаковых
;-z, --zero-terminated
:вместо символа новой строки (newline), завершает строки двоичным 0
;--help
:вывести справку о программе, её параметрах и завершить работу
;--version
: вывести информацию о версии программы и завершить работу
Синтаксис параметра ''-k'', ''--key=ПОЗ1[,ПОЗ2]'' означает следующее: 
''ПОЗ'' указывается в формате ''F[.C][OPTS]'', где ''F'' является порядковым номером поля, а ''C'' позицией символа в этом поле. ''OPTS'' представляет собой одну или более одиночных букв, которые означают рассмотренные выше параметры и их действие перекрывает действие глобальных параметров для этого ключа. Если ни один ключ не задан, в качестве ключа используется вся строка. Ключ сортировки — это часть строки, которая рассматривается при сортировке, вместо того чтобы рассматривалась вся строка. Таким образом, команда:
;sort -k1.3 
осуществляет сортировку по первому полю, начиная с его третьего символа. Команда:
;sort -k4.6,7n
означает сортировку с 6-го символа четвёртого поля до 1-го символа седьмого поля. Сортировка ведётся по числовому значению. Допускается задание нескольких параметров ''-k'' для того, чтобы определить несколько ключей, которые будут использованы последовательно в том порядке, в котором они указаны в командной строке. Величина размера ''SIZE'' памяти, отводимой для работы команды [[sort]] может быть задана со следующими суффиксами: ''%-1%'' от общей памяти; ''b'' — в байтах; ''K'' — 1024 байт (по умолчанию); и соответственно для ''M'', ''G'', ''T'', ''P'', ''E'', ''Z'', ''Y''. Если в командной строке не указан никакой файл или вместо имени стоит дефис, считывается стандартный ввод (с клавиатуры).

== Примеры ==
;Отсортировать файл ''f1'', используя в качестве ключа второе поле:
: ''sort +1 -2 f1''
;Отсортировать по убыванию содержимое файлов ''f2'' и ''f3'', поместив результат в файл ''f4''. Ключом сортировки служит первый символ второго поля<nowiki>:</nowiki>
: ''sort -r -o f4 +1.0 -1.2 f2 f3''
;Отсортировать по убыванию содержимое файлов ''f5'' и ''f6''. Ключом сортировки служит первый не пробел второго поля<nowiki>:</nowiki>
: ''sort -r +1.0b -1.1b f5 f6''
;Распечатать файл паролей, отсортировав его по числовым значениям идентификаторов пользователей (третье поле, поля разделяются символом <nowiki>:):</nowiki>
: ''sort -t: +2n -3 /etc/passwd''
;Распечатать строки уже отсортированного файла ''f7'', выводя лишь первую из строк с одинаковыми третьими полями<nowiki>:</nowiki>
: ''sort -um +2 -3 f7''

== Диагностика ==
Если в последней строке файла пропущен символ возврата каретки, то он добавляется автоматически, о чем выдаётся предупреждение.

== Предостережения ==
Не гарантируется сохранение порядка следования строк с равными ключами. Не оговаривается приоритет различных способов сравнения (например, числового и словарного), поэтому задавать комбинацию флагов ''dMn'' не имеет смысла.

Usermod

2018-01-09T12:00:43Z

Vaal: Новая страница: «'''usermod'''(от англ. '''user''' '''mod'''ification) - изменяет учётную запись пользователя. == Синтаксис…»

'''usermod'''(от англ. '''user''' '''mod'''ification) - изменяет учётную запись пользователя. 
== Синтаксис ==
'''usermod''' [''параметры''] ''LOGIN''
== Описание ==
Команда '''usermod''' изменяет системные файлы учётных записей согласно переданным в командной строке параметрам.
== Параметры ==
Параметры команды '''usermod''':
;-a, --append
: Добавить пользователя в дополнительную группу(ы). Использовать только вместе с параметром ''-G''.
;-c, --comment КОММЕНТАРИЙ
: Новое значение поля комментария в файле пользовательских паролей. Обычно его изменяют с помощью программы '''chfn'''.
;-d, --home ДОМАШНИЙ_КАТАЛОГ
: Новый домашний каталог пользователя. Если указан параметр ''-m'', то содержимое текущего домашнего каталога будет перемещено в новый домашний каталог, который будет создан, если он ещё не существует.
;-e, --expiredate ДАТА_УСТАРЕВАНИЯ
: Дата, когда учётная запись пользователя будет заблокирована. Дата задаётся в формате <ГГГГ>-<ММ>-<ДД>.
;-f, --inactive ДНЕЙ
: Число дней, которые должны пройти после устаревания пароля, чтобы учётная запись заблокировалась навсегда. Если указано значение 0, то учётная запись блокируется сразу после устаревания пароля, а при значении -1 данная возможность не используется. По умолчанию используется значение -1.
;-g, --gid ГРУППА
: Имя или числовой идентификатор новой начальной группы пользователя. Группа с таким именем должна существовать. Идентификатор группы должен указывать на уже существующую группу. По умолчанию идентификатор группы установлен в 1.
;-G, --groups ГРУППА1[,ГРУППА2,...[,ГРУППАN]]]
: Список дополнительных групп, членом которых также является пользователь. Каждая группа отделена от следующей запятой, без промежуточных пробелов. Группы подвержены тем же ограничениям, что и группа, заданная с опцией ''-g''. Если пользователь в настоящее время является членом группы, которая не указана в списке, пользователь будет удален из группы. Такое поведение можно изменить с помощью опции ''-a'', которая добавляет пользователя в текущий список дополнительных групп.
;-l, --login НОВОЕ_ИМЯ
: Имя пользователя будет изменено с ''LOGIN'' на ''NEW_LOGIN''. Ничего другого не изменилось. В частности, имя домашнего каталога пользователя, вероятно, должно быть изменено вручную, чтобы отобразить новое имя входа.
;-L, --lock
: Заблокировать пароль пользователя. Это делается помещением символа '!' в начало шифрованного пароля, чтобы приводит к блокировке пароля. Не используйте этот параметр вместе с ''-p'' или ''-U''. '''Примечание''': Если вы хотите заблокировать учетную запись (не только доступ по паролю), вы также должны установить для ''EXPIRE_DATE'' значение 1.
;-o, --non-unique
: При использовании с параметром ''-u'', этот параметр позволяет указывать не уникальный числовой идентификатор пользователя.
;-p, --password ПАРОЛЬ
: Шифрованное значение пароля, которое возвращает функция '''crypt'''.
;-s, --shell ОБОЛОЧКА
: Имя новой регистрационной оболочки пользователя. Если задать пустое значение, то будет использована регистрационная оболочка по умолчанию.
;-u, --uid UID
: Числовое значение идентификатора пользователя (''ID''). Значение должно быть уникальным, если не задан параметр ''-o''. Значение должно быть неотрицательным. Значения от 0 до 999 обычно зарезервированы для системных учётных записей. Для всех файлов, которыми владеет пользователь и которые расположены в его домашнем каталоге идентификатор владельца файла будет изменён автоматически. Для файлов, расположенных вне домашнего каталога идентификатор нужно изменять вручную.
;-U, --unlock
: Разблокировать пароль пользователя. Это выполняется удалением символа '!' из начала шифрованного пароля. Не используйте этот параметр вместе с ''-p'' или ''-L''. '''Примечание''': Если вы хотите разблокировать учетную запись (не только доступ по паролю), вы также должны установить ''EXPIRE_DATE''(например, 99999 или значение EXPIRE из ''/etc/default/useradd'').
== Предостережения ==
Команда '''usermod''' не будет изменять имя пользователя, если этот пользователь в данный момент работает в системе. Если требуется изменить числовой идентификатор пользователя, нужно проверить, что от этого пользователя нет запущенных процессов. Владельца файлов '''crontab''' нужно изменять вручную. Владельца заданий '''at''' нужно изменять вручную. Также вручную нужно сделать все изменения связанные с ''NIS'' на сервере ''NIS''.
== Конфигурация ==
Следующие переменные конфигурации в файле ''/etc/login.defs'' изменяют поведение этого инструмента:
;MAIL_DIR (string)
: Почтовый каталог. Данный параметр нужен для управления почтовым ящиком при изменении или удалении учётной записи пользователя. Если параметр не задан, то используется значение указанное при сборке.
;MAIL_FILE (string)
: Определяет расположение файлов, содержащих почтовые сообщения пользователей, относительно их домашнего каталога. Переменные ''MAIL_DIR'' и ''MAIL_FILE'' используются [[useradd]], [[usermod]] и [[userdel]] для создания, перемещения или удаления файлов, содержащих почтовые сообщения пользователей. Если для ''MAIL_CHECK_ENAB'' установлено значение ''yes'', они также используются для определения переменной среды ''MAIL''.
;MAX_MEMBERS_PER_GROUP (number)
: Максимальное количество участников в группе. Когда достигнут максимум, в ''/etc/group'' запускается новая запись(строка) группы (с тем же именем, с тем же паролем и с тем же ''GID''). Значение по умолчанию равно 0, а это означает, что число членов в группе не ограничено. Эта функция(разделённая группа) позволяет ограничить длину строк в файле группы. Это полезно, чтобы убедиться, что строки для групп ''NIS'' не более 1024 символов. Если вам необходимо обеспечить соблюдение такого ограничения, вы можете использовать 25. '''Примечание''': Разделённые группы могут не поддерживаться всеми инструментами (даже в инструменте '''shadow'''. Вы не должны использовать эту переменную, если она вам не нужна).
== Файлы ==
;/etc/group
: Содержит информацию о группах
;/etc/passwd
: Содержит информацию о пользователях
;/etc/shadow
: Содержит защищаемую информацию о пользователях

Userdel

2018-01-09T12:00:21Z

Vaal: Новая страница: «'''userdel'''(от англ. '''user''' '''del'''ete) - удаляет учётную запись и файлы пользователя. == Синтакс…»

'''userdel'''(от англ. '''user''' '''del'''ete) - удаляет учётную запись и файлы пользователя. 
== Синтаксис ==
'''userdel''' [''параметры''] ''LOGIN''
== Описание ==
Команда [[userdel]] изменяет файлы системной учетной записи, удаляя все записи, относящиеся к имени пользователя ''LOGIN''. Именованный пользователь должен существовать.
== Параметры ==
Параметры команды '''userdel'':
;-f, --force
: Этот параметр заставляет удалять учётную запись пользователя, даже если пользователь всё ещё зарегистрирован. Он также заставляет [[userdel]] удалять домашний каталог пользователя и файлы, содержащие почтовые сообщения, даже если другой пользователь использует тот же домашний каталог, или, если файлы не принадлежит указанным пользователем. Если ''USERGROUPS_ENAB'' определено в ''yes'' в ''/etc/login.defs'', и если группа существует с тем же именем, что и удалённый пользователь, эта группа будет удалена, даже если она по-прежнему является основной группой другого пользователя. '''Примечание''': Этот параметр опасно использовать; он может привести систему в нерабочее состояние.
;-h, --help
: Показать краткую справку и закончить работу.
;-r, --remove
: Файлы в домашнем каталоге пользователя будут удалены вместе с самим домашним каталогом и почтовым ящиком. Пользовательские файлы, расположенные в других файловых системах, нужно искать и удалять вручную. Имя файла почтового ящика задаётся переменной ''MAIL_DIR'' в файле ''login.defs''.
== Замечания ==
== Предостережения ==
== Конфигурация ==
Следующие переменные конфигурации в файле ''/etc/login.defs'' изменяют поведение этого инструмента:
;MAIL_DIR (string)
: Почтовый каталог. Данный параметр нужен для управления почтовым ящиком при изменении или удалении учётной записи пользователя. Если параметр не задан, то используется значение указанное при сборке.
;MAIL_FILE (string)
: Определяет расположение файлов почтовых спутников пользователей относительно их домашнего каталога. Переменные ''MAIL_DIR'' и ''MAIL_FILE'' используются [[useradd]], [[usermod]] и [[userdel]] для создания, перемещения или удаления почтовой катушки пользователя. Если для ''MAIL_CHECK_ENAB'' установлено значение ''yes'', они также используются для определения переменной среды ''MAIL''.
;MAX_MEMBERS_PER_GROUP (number)
: Максимальное количество участников в группе. Когда достигнут максимум, в ''/etc/group'' запускается новая запись(строка) группы(с тем же именем, с тем же паролем и с тем же ''GID''). Значение по умолчанию равно 0, а это означает, что число членов в группе не ограничено. Эта функция(разделенная группа) позволяет ограничить длину строк в файле группы. Это полезно, чтобы убедиться, что строки для групп ''NIS'' не более 1024 символов. Если вам необходимо обеспечить соблюдение такого ограничения, вы можете использовать 25. '''Примечание''': Разделённые группы могут не поддерживаться всеми инструментами(даже в инструменте '''shadow'''. Вы не должны использовать эту переменную, если она вам не нужна).
;USERDEL_CMD (string)
: Определяет программу, которая будет запущена при удалении пользователя. Она должна удалять любые задания ''at/cron/печати'' удаляемого пользователя(передаётся в качестве первого аргумента).
;USERGROUPS_ENAB (boolean)
: Включить настройку битов группы ''umask'' как то же, что и биты владельца (примеры: 022 -> 002, 077 -> 007) для пользователей, не являющихся '''root''', если ''uid'' совпадает с именем ''gid'', а имя пользователя совпадает с именем основного названия группы. Если установлено ''yes'', [[userdel]] удалит группу пользователя, если в неё не будет больше членов, а [[useradd]] будет создавать по умолчанию группу с именем пользователя.
== Файлы ==
;/etc/group
: Содержит информацию о группах
;/etc/login.defs
: Содержит конфигурацию подсистемы теневых паролей
;/etc/passwd
: Содержит информацию о пользователях
;/etc/shadow
: Содержит защищаемую информацию о пользователях
== Возвращаемые значения ==
Команда [[userdel]] завершая работу, возвращает следующие значения:
;0
: успешное выполнение
;1
: не удалось изменить файл паролей
;2
: ошибка в параметрах команды
;6
: указанный пользователь не существует
;8
: пользователь сейчас работает в системе
;10
: не удалось изменить файл групп
;12
: не удалось удалить домашний каталог
== Предостережения ==
Команда [[userdel]] не будет удалять учётную запись, если пользователь в данный момент работает в системе. Вы должны завершить все запущенные процессы, принадлежащие учётной записи, которую нужно удалить. Нельзя удалить ''NIS'' атрибуты клиента ''NIS''. Это необходимо сделать на ''NIS'' сервере. Если значение переменной ''USERGROUPS_ENAB'' равно ''yes'' в файле ''/etc/login.defs'', то [[userdel]] удалит группу с именем как у пользователя. Чтобы избежать рассогласованности в базах данных групп и паролей, [[userdel]] проверит, что данная группа не используется в качестве первичной для другого пользователя, и выдаст предупреждение без удаления, если такое случится. Параметр ''-f'' поможет удалить группу в любом случае.

Useradd

2018-01-09T11:59:14Z

Vaal: Новая страница: «'''useradd'''(от англ. '''user''' '''add''') — регистрирует нового пользователя или изменяет информацию…»

'''useradd'''(от англ. '''user''' '''add''') — регистрирует нового пользователя или изменяет информацию по умолчанию о новых пользователях. 
== Синтаксис ==
'''useradd''' [''параметры''] ''LOGIN'' 
'''useradd -D''' 
'''useradd -D''' [''параметры''] 
== Описание ==
При вызове без опции ''-D'' команда '''''useradd''''' создаёт новую учётную запись пользователя, используя значения, указанные в командной строке, а также значения по умолчанию из системы. В зависимости от параметров командной строки команда '''''useradd''''' будет обновлять системные файлы, а также может создавать домашний каталог нового пользователя и копировать исходные файлы. 
Когда мы в терминале запускаем команду '''''useradd''''', происходит следующее:
#Она редактирует файлы ''/etc/passwd'', ''/etc/shadow'', ''/etc/group'' и ''/etc/gshadow'', внося в них нового пользователя.
#Создаётся и заполняется домашняя директория для нового пользователя.
#Устанавливаются права доступа и владелец домашней директории. 
== Параметры ==
Параметры команды '''''useradd''''':
;-c, --comment КОММЕНТАРИЙ
: Любая текстовая строка. Обычно, здесь коротко описывается учётная запись, и в настоящее время используется как поле для имени и фамилии пользователя.
;-b, --base-dir БАЗОВЫЙ_КАТАЛОГ
: Базовый каталог по умолчанию для системы, если ''-d HOME_DIR'' не указан. ''BASE_DIR'' объединяется с именем учётной записи, чтобы определить домашний каталог. Если опция ''-m'' не используется, ''BASE_DIR'' должен существовать.
;-D, --defaults
: См. Ниже раздел «Изменение значений по умолчанию».
;-d, --home ДОМАШНИЙ_КАТАЛОГ
: Для создаваемого пользователя будет использован каталог ''БАЗОВЫЙ_КАТАЛОГ'' в качестве начального каталога. По умолчанию, это значение получается объединением ''ИМЕНИ'' пользователя с ''БАЗОВЫМ_КАТАЛОГОМ'' и используется как имя домашнего каталога. Каталог ''БАЗОВЫЙ_КАТАЛОГ'' необязательно должен существовать и не будет создан, если его нет.
;-e, --expiredate ДАТА_УСТАРЕВАНИЯ
: Дата, когда учётная запись пользователя будет заблокирована. Дата задаётся в формате <ГГГГ>-<ММ>-<ДД>.
;-f, --inactive ДНЕЙ
: Число дней, которые должны пройти после устаревания пароля, чтобы учётная запись заблокировалась навсегда. Если указано значение 0, то учётная запись блокируется сразу после устаревания пароля, а при значении -1 данная возможность не используется. По умолчанию используется значение -1.
;-g, --gid ГРУППА
: Имя или числовой идентификатор новой начальной группы пользователя. Группа с таким именем должна существовать. Идентификатор группы должен указывать на уже существующую группу. Идентификатор группы по умолчанию равен 1 или значению указанному в файле ''/etc/default/useradd''.
;-G, --groups ГРУППА 1 [,ГРУППА 2,...[,ГРУППА N]]]
: Список дополнительных групп, в которых числится пользователь. Перечисление групп осуществляется через запятую, без промежуточных пробелов. На указанные группы действуют те же ограничения, что и для группы указанной в параметре ''-g''. По умолчанию пользователь входит только в начальную группу.
;-h, --help
: Показать краткую справку и закончить работу.
;-m, --create-home
: Если домашнего каталога пользователя не существует, то он будет создан. Файлы из каталога ''КАТАЛОГ_ШАБЛОН'' будут скопированы в домашний каталог, если он указан параметр ''-k'', иначе будут использованы файлы из каталога ''/etc/skel''. Все подкаталоги каталога ''КАТАЛОГ_ШАБЛОН'' или ''/etc/skel'' будут также созданы в домашнем каталоге пользователя. Параметр ''-k'' можно использовать только вместе с параметром ''-m''. По умолчанию, домашний каталог не создаётся и файлы не копируются.
;-K, --key КЛЮЧ=ЗНАЧЕНИЕ
: Используется для изменения значений по умолчанию, хранимых в файле ''/etc/login.defs'' (''UID_MIN'', ''UID_MAX'', ''UMASK'', ''PASS_MAX_DAYS'' и других). Пример: ''-K PASS_MAX_DAYS=-1'' можно использовать при создании системной учётной записи, чтобы выключить устаревание пароля, даже если системная учётная запись вообще не имеет пароля. Можно указывать параметр ''-K'' несколько раз, например: ''-K UID_MIN=100 -K UID_MAX=499''. Замечание: запись вида ''-K UID_MIN=10,UID_MAX=499'' пока не работает.
;-l
: Не добавляйте пользователя в базы данных ''lastlog'' и ''faillog''. По умолчанию записи пользователя в базе данных ''lastlog'' и ''faillog'' сбрасываются, чтобы избежать повторного использования записи от ранее удаленного пользователя.
;-N, --no-user-group
: Не создавать группу с тем же именем, что и пользователь, но добавить пользователя в группу, указанную опцией ''-g'' или переменной ''GROUP'' в ''/etc/default/useradd''. Поведение по умолчанию (если параметры ''-g'', ''-N'' и ''-U'' не указаны) определяется переменной ''USERGROUPS_ENAB'' в ''login.defs''.
;-o, --non-unique
: Позволяет создать учётную запись с уже имеющимся (не уникальным) ''UID''.
;-p, --password ПАРОЛЬ
: Шифрованное значение пароля, которое возвращает функция '''''crypt'''''. По умолчанию учётная запись заблокирована.
;-s, --shell ОБОЛОЧКА
:Имя регистрационной оболочки пользователя. Если задать пустое значение, то будет использована регистрационная оболочка по умолчанию.
;-u, --uidUID
: Числовое значение идентификатора пользователя (''ID''). Оно должно быть уникальным, если не используется параметр ''-o''. Значение должно быть неотрицательным. По умолчанию используется наименьшее значение ''ID'' большее 999 и большее любого другого значения пользователя. Значения от 0 до 999 обычно зарезервированы для системных учётных записей.
;-U, --user-group
: Создайте группу с тем же именем, что и пользователь, и добавьте пользователя в эту группу. Поведение по умолчанию (если параметры ''-g'', ''-N'' и ''-U'' не указаны) определяется переменной ''USERGROUPS_ENAB'' в ''login.defs''.

== Изменение значений по умолчанию ==
При вызове только с параметром ''-D'' '''''useradd''''' отображает текущие значения по умолчанию. При вызове с ''-D'' плюс другие параметры, '''''useradd''''' будет обновлять значения по умолчанию для указанных параметров. Допустимыми параметрами изменения по умолчанию являются:
;-b, --base-dir БАЗОВЫЙ_КАТАЛОГ
: Префикс пути для домашнего каталога нового пользователя. Имя пользователя будет прикреплено к концу ''BASE_DIR'', чтобы сформировать имя домашнего каталога нового пользователя, если параметр ''-d'' не используется при создании новой учётной записи.
;-e, --expiredate ДАТА_УСТАРЕВАНИЯ
: Дата, когда учётная запись пользователя заблокирована.
;-f, --inactive ДНЕЙ
: Число дней, которые должны пройти после устаревания пароля, перед тем как учётная запись будет заблокирована.
;-g, --gid ГРУППА
: Имя или числовой идентификатор новой начальной группы пользователя. Группа с таким именем должна существовать и для числового идентификатора должна быть запись.
;-s, --shell ОБОЛОЧКА
: Имя оболочки входа нового пользователя.

== Замечания ==
Системный администратор сам решает, какие файлы нужно положить в каталог ''/etc/skel/''.

== Предостережения ==
Вы не можете добавить пользователя в группу ''NIS'' или ''LDAP''. Это должно быть выполнено на соответствующем сервере. Аналогично, если имя пользователя уже существует во внешней пользовательской базе данных, такой как ''NIS'' или ''LDAP'', '''''useradd''''' будет отклонять запрос на создание учётной записи пользователя. Имена пользователей должны начинаться со строчной буквы или символа подчёркивания, и должны состоять только из строчных букв, подписи, тире и знака доллара. Это можно описать регулярным выражением: [a-z _] [a-z0-9 _-] * [$]

== Конфигурация ==
Следующие переменные конфигурации в файле ''/etc/login.defs'' изменяют поведение этого инструмента:
;GID_MAX (number), GID_MIN (number)
: Диапазон идентификаторов групп, используемых для создания регулярных групп с помощью '''''useradd''''', '''''usermod''''' или '''''newusers'''''.
;MAIL_DIR (string)
: Почтовый каталог. Данный параметр нужен для управления почтовым ящиком при изменении или удалении учётной записи пользователя. Если параметр не задан, то используется значение указанное при сборке.
;MAIL_FILE (string)
: Определяет расположение файлов пользователей, в которых хранится почта, относительно их домашнего каталога. Переменные ''MAIL_DIR'' и ''MAIL_FILE'' используются '''''useradd''''', '''''usermod''''' и '''''userdel''''' для создания, перемещения или удаления файлов пользователя, в которых хранится почта. Если для ''MAIL_CHECK_ENAB'' установлено значение ''yes'', они также используются для определения переменной среды ''MAIL''.
;MAX_MEMBERS_PER_GROUP (number)
: Максимальное количество участников в группе. Когда достигнут максимум, в ''/etc/group'' запускается новая запись(строка) группы (с тем же именем, с тем же паролем и с тем же ''GID''). Значение по умолчанию равно 0, а это означает, что число членов в группе не ограничено. Эта функция (разделённая группа) позволяет ограничить длину строк в файле группы. Это полезно, чтобы убедиться, что строки для групп ''NIS'' не более 1024 символов. Если вам необходимо обеспечить соблюдение такого ограничения, вы можете использовать ''25''. '''Примечание'''. Разделённые группы могут не поддерживаться всеми инструментами (даже в инструменте ''shadow''. Вы не должны использовать эту переменную, если она вам не нужна).
;PASS_MAX_DAYS (number)
: Максимальное число дней использования пароля. Если пароль старее этого числа, то будет запущена процедура смены пароля. Если значение не задано, то предполагается значение -1 (то есть возможность ограничения не используется).
;PASS_MIN_DAYS (number)
: Максимальное число дней между изменениями пароля. Любая смена пароля ранее заданного срока выполнена не будет. Если значение не задано, то предполагается значение -1 (то есть возможность ограничения не используется).
;PASS_WARN_AGE (number)
: Число дней за которое начнёт выдаваться предупреждение об устаревании пароля. Нулевое значение означает, что предупреждение выдаётся в день устаревания, при отрицательном значении предупреждение выдаваться не будет. Если значение не задано, выдача предупреждения отключается.
;SYS_GID_MAX (number), SYS_GID_MIN (number)
: Диапазон идентификаторов групп, используемых для создания системных групп с помощью '''''useradd''''', '''''groupadd''''' или '''''newusers'''''.
;SYS_UID_MAX (number), SYS_UID_MIN (number)
: Диапазон идентификаторов пользователей, используемых для создания пользователей системы с помощью '''''useradd''''' или '''''newusers'''''.
;UID_MAX (number), UID_MIN (number)
: Диапазон идентификаторов пользователей, используемых для создания обычных пользователей с помощью '''''useradd''''' или '''''newusers'''''.
;UMASK (number)
: Задаёт начальное значение маски доступа. Если не указано, то маска доступа устанавливается в 022.

== Файлы ==
;/etc/passwd
: содержит информацию о пользователях
;/etc/shadow
: содержит защищаемую информацию о пользователях
;/etc/group
: содержит информацию о группах
;/etc/default/useradd
: содержит защищаемую информацию о пользователях
;/etc/skel/
: каталог, содержащий пользовательские файлы по умолчанию
;/etc/login.defs
: содержит конфигурацию подсистемы теневых паролей

== Возвращаемые значения ==
;0
: успешное выполнение
;1
: не удалось изменить файл паролей
;2
: ошибка в параметрах команды
;3
: недопустимое значение параметра
;4
: такой UID уже существует (и не задан параметр -o)
;6
: указанная группа не существует
;9
: имя пользователя уже существует
;10
: не удалось изменить файл групп
;12
: не удалось создать домашний каталог
;13
: не удалось создать почтовый ящик

Mktemp

2017-12-07T10:00:16Z

Vaal:

== Описание ==
'''mktemp''' (от англ. '''m'''a'''k'''e '''temp'''late) - утилита для создания временного файла или каталога. 
Создаёт временный файл или каталог, безопасно печатает его имя. ''TEMPLATE'' должен содержать как минимум 3 последовательных символа «''X''» в последнем компоненте. Если ''TEMPLATE'' не указан, используйте '''tmp'''.''XXXXXXXXXX'' и ''--tmpdir''. Файлы создаются с выставленными правами ''u+rw'', а каталоги — ''u+rwx'', минус ограничения [[umask]].

== Использование ==
* <tt>mktemp [OPTION] ... [TEMPLATE]</tt>

;-d, --directory
: создать каталог, а не файл.

;-u, --dry-run
: ничего не создаёт; просто напечатает имя (небезопасно).

;-q, --quiet
: подавить диагностику ошибки создания файла/каталога.

;--suffix = SUFF
: добавляет SUFF в TEMPLATE; SUFF не должен содержать косой черты. Этот параметр подразумевает, если TEMPLATE не заканчивается на X.

;-p DIR, --tmpdir [= DIR]
: интерпретировать TEMPLATE относительно DIR; если DIR не указан, используйте $TMPDIR, если установлено, иначе /tmp. С помощью этой опции, TEMPLATE не может быть абсолютным именем; в отличие от -t, TEMPLATE может содержать косые черты, но [[mktemp]] создаёт только конечный компонент.

;-t
: интерпретировать TEMPLATE как единый компонент имени файла относительно каталога $TMPDIR, если он установлен; иначе каталог указан через '''-p'''; иначе /tmp [устарело]

;--help
: отобразить эту справку и выйти

;--version
: вывести информацию об утилите и выйти

== Ссылки ==
[http://www.gnu.org/software/coreutils/ Справочная информация GNU coreutils] 
[http://translationproject.org/team/ Сообщить об ошибках перевода mktemp]

Diskadd

2017-11-27T07:04:29Z

Vaal:

В данной статье рассматривается вопрос добавления диска и распределения дискового пространства в виртуальной машине '''VMWare''', с установленной ОС '''RHEL 6.x'''. 
Распределение дискового пространства будет проходить на корневую директорию "/" средствами [[lvm]].
= Добавление HDD в виртуальную машину =
Для добавления диска в виртуальную машину '''VMWare''', требуется выполнить следующие шаги: 
1) В случае, если ВМ, на которой требуется увеличить дисковое пространство, выключена необходимо произвести запуск ВМ. 
2) В Библиотеке("'''''Library'''''") правой клавишей мыши открыть контекстное меню ВМ, выбрать элемент "'''''Settings'''''", раскрывшегося контекстного меню. 
[[File:Vm_add_disk-space_01.jpg|900px|center]]
3) В открывшемся окне "'''''Virtual Machine Settings'''''", на вкладке "'''''Hardware'''''", нажать кнопку "'''''Add'''''". 
[[File:Vm_add_disk-space_02.jpg|500px|center]]
4) В окне мастера "'''''Add Hardware Wizard'''''" выбрать элемент "'''''Hard Disk'''''" списка "'''''Hardware Types'''''" и нажать кнопку "'''''Next'''''". 
[[File:Vm_add_disk-space_03.jpg|500px|center]]
5) На вкладке "'''''Select a Disk Type'''''" выбираем рекомендуемые параметры, нажимаем кнопку "'''''Next'''''". 
[[File:Vm_add_disk-space_04.jpg|500px|center]]
6) На вкладке "'''''Select a Disk'''''", выбираем значение "'''''Create a new virtual disk'''''", нажимаем кнопку "'''''Next'''''". 
[[File:Vm_add_disk-space_05.jpg|500px|center]]
7) На вкладке "'''''Specify Disk Capacity'''''", выставляем необходимые значения объёма диска("'''''Maximum disk size'''''"), распределить весь выделенный объём сразу("'''''Allocate all disk space now'''''"), хранить виртуальный диск в одном("'''''single file'''''") или в нескольких("'''''multiple files'''''") файлах, нажимаем кнопку "'''''Next'''''". 
[[File:Vm_add_disk-space_06.jpg|500px|center]]
8) На вкладке "'''''Specify Disk File'''''", задаём имя файла("'''''File name'''''") виртуального диска, нажимаем кнопку "'''''Finish'''''". 
[[File:Vm_add_disk-space_07.jpg|500px|center]]
9) В окне "'''''Virtual Machine Settings'''''" нажимаем кнопку "'''''Ok'''''".
[[File:Vm_add_disk-space_08.jpg|500px|center]]

= Сканирование шины после добавления HDD =
Если добавить новый жёсткий диск в ВМ(виртуальную машину) VMware, он будет отображён только после перезагрузки виртуальной машины. Необходимо запустить сканирование шины '''''SCSI''''' в рабочей виртуальной машине для принудительного считывания подключенных дисков. Ниже приведены требуемые операции.
 
1) Сначала, необходимо определить идентификатор шины:
:<nowiki>#</nowiki> ls /sys/class/scsi_host host0
В примере идентификатор шины: host0. 
2) Затем, принудительное сканирование, замена host0 полученными данными:
:<nowiki># </nowiki>echo "- - -" > /sys/class/scsi_host/host0/scan 
Теперь можно запустить [[fdisk|fdisk -l]] и посмотреть изменения. Задача решена. В виртуальную машину Linux добавлен диск без необходимости перезагрузки. 
Может быть случай, когда на первом шаге будет выдан результат, включающий в себя большое количество host*, т.е. будет выведен диапазон значений, например: host0, host1, host2, host3, host4, host5, host6...hostN 
В таком случае, команду принудительного сканирования на шаге 2), надо выполнять в следующем виде:
:<nowiki># </nowiki>cd /sys/class/scsi_host/; for i in /sys/class/scsi_host/host*; do echo "- - -" > $i/scan; done 
::::::::::или
:<nowiki># </nowiki>for i in {1..N}; do echo "- - -" > /sys/class/scsi_host/host$i/scan; done где ''N'', максимальное значение идентификатора шины, при выполнении команды ls /sys/class/scsi_host.

= Расширение корневой партиции средствами lvm =
В этой главе используется ОС RHEL 6.x (но также применимо к любому другому дистрибутиву Linux), который имеет раздел ''ext4'' '''''lv_root''''', установленный как "/" и '''''lv_swap''''', как своп из группы томов '''''vg_rhel69''''' (по умолчанию), имитируем, что у нас заканчивается пространство в '''''lv_root''''' ("/") и группе томов ('''''vg_rhel69''''') нет свободного пространства. В предыдущих главах добавили новый диск с объёмом 20 ГБ. Теперь нужно назначить это пространство объёмом 20 ГБ группе томов, а затем расширить '''''lv_root'''''("/"). 
'''Внимание''': '''сохраните все важные данные, хранящиеся на ВМ'''! 
1) Сперва проверим использование дискового пространства файловой системы и информацию о логическом томе:
:<nowiki># df -h</nowiki> 
:<nowiki># lvs</nowiki> 
[[File:Vm_add_disk-space_09.jpg|600px|center]]
2) Получаем информацию о новых добавленных дисках:
:<nowiki>#</nowiki> fdisk -l 
[[File:Vm_add_disk-space_10.jpg|500px|center]]
3) Создаём партицию на новом жёстком диске, используя LVM(8e)(на рисунке представлена последовательность выполнения операций):
:<nowiki>#</nowiki> fdisk /dev/sdс 
[[File:Vm_add_disk-space_11.jpg|500px|center]]
4) Идентифицируем тип файловой системы на смонтированных устройствах:
:<nowiki>#</nowiki> df -T 
[[File:Vm_add_disk-space_12.JPG|center]]
5) Форматируем вновь созданную партицию следующей командой:
:<nowiki>#</nowiki> mkfs.ext4 /dev/sdc1 
[[File:Vm_add_disk-space_13.jpg|center]]
6) Инициализируем созданную партицию как физический том:
:<nowiki>#</nowiki> pvcreate /dev/sdc1 
[[File:Vm_add_disk-space_14.jpg|center]]
7) Сканируем группы томов используя следующую команду:
:<nowiki>#</nowiki> vgs 
[[File:Vm_add_disk-space_15.jpg|center]]
8) Расширяем группу томов ("''''vg_rhel69'''") новым физическим томом("'''/dev/sdc1'''"):
:<nowiki>#</nowiki> vgextend vg_rhel69 /dev/sdc1 
[[File:Vm_add_disk-space_16.jpg|center]]
9) Расширим логический том ("'''lv_root'''") всем свободным пространством группы томов("'''vg_rhel69'''"):
:<nowiki>#</nowiki> lvextend -l +100%FREE /dev/vg_rhel69/lv_root 
[[File:Vm_add_disk-space_17.jpg|center]]
10) В конце изменяем размер файловой системы на логическом томе "'''lv_root'''":
:<nowiki>#</nowiki> resize2fs /dev/vg_rhel69/lv_root 
[[File:Vm_add_disk-space_18.jpg|center]]
11) Верифицируем, что корневой раздел на файловой системе увеличен, выполняя следующие команды:
:<nowiki>#</nowiki> df -h 
:<nowiki>#</nowiki> lvs 
:<nowiki>#</nowiki> vgs 
[[File:Vm_add_disk-space_19.jpg|center]]

= Ссылки =
[https://rbgeek.wordpress.com/2013/01/27/how-to-extend-the-root-partition-in-lvm/ Как расширить корневую партицию в LVM] 
[http://melfis.ru/подключение-жестких-дисков-на-горячу/ Подключение HDD на горячую] 
[https://notessysadmin.com/resize-lvm-on-centos7 Особенность расширения LVM тома на CentOS 7]

ProFTPD vsFTPD

2017-11-21T08:55:38Z

Vaal:

== Введение ==
В данной статье кратко описан процесс развёртывание сервиса ftp на серверах с установленными ОС RHEL 6.x(CentOS 6.x) и RHEL 7.x(CetnOS 7.x). 
Для ОС RHEL 6.x(CentOS 6.x) рассмотрена установка vsFTPD, в то время как для RHEL 7.x(CetnOS 7.x) — ProFTPD. Желательно наличие в системе подключенного репозитория [https://www.shellhacks.com/ru/epel-repo-centos-7-6-install/ EPEL].

== Установка vsFTPD в RHEL 6.x(CentOS 6.x) ==
1) Создаём пользователя '''''ftpuser''''', назначаем ему домашнюю директорию '''/opt/ftp''':
:<nowiki>#</nowiki> useradd -d '/opt/ftp' -s /sbin/nologin ftpuser
2) Устанавливаем пароль для нового пользователя:
:<nowiki>#</nowiki> passwd ftpuser
3) Создаём группу '''''ftpusers''''' для FTP пользователей, и добавляем в нее '''''ftpuser''''':
:<nowiki>#</nowiki> groupadd ftpusers
:<nowiki>#</nowiki> usermod -G ftpusers ftpuser
4) Разрешаем пользователю чтение/запись в домашнюю директорию, изменяем права доступа и владельца:
:<nowiki>#</nowiki> chown -R ftpuser:ftpusers '/opt/ftp'
:<nowiki>#</nowiki> chmod 775 '/opt/ftp'
5) Устанавливаем vsftpd:
:<nowiki>#</nowiki> yum install vsftpd -y
6) Добавляем сервис в автозагрузку:
:<nowiki>#</nowiki> chkconfig --levels 235 vsftpd on
7) Стартуем сервис:
:<nowiki>#</nowiki> service vsftpd start
8) Создаём резервную копию конфигурационного файла vsftpd.conf:
:<nowiki>#</nowiki> cp /etc/vsftpd/vsftpd.conf /etc/vsftpd/vsftpd.conf.bkp
9) Создаём файл '''/etc/vsftpd/chroot_list''', внеся в него имя пользователя:
:<nowiki>#</nowiki> echo 'ftpuser /opt/ftp'>/etc/vsftpd/chroot_list
10) Открываем в редакторе ([[vim]], [[vim|vi]], nano) файл '''/etc/vsftpd/vsftpd.conf''', и вносим изменения в следующие параметры (если параметр закомментирован его надо раскомментировать, если отсутствует — создать):
:::'''anonymous_enable=NO'''
:::'''local_enable=YES'''
:::'''write_enable=YES'''
:::'''local_umask=022'''
:::'''xferlog_enable=YES'''
:::'''dual_log_enable=YES'''
:::'''chown_uploads=YES'''
:::'''chown_username=ftpuser'''
:::'''chroot_local_user=YES'''
:::'''chroot_list_enable=YES'''
:::'''chroot_list_file=/etc/vsftpd/chroot_list'''
:::'''use_localtime=YES'''
11) Перезапускаем сервис, удаляем лишнее:
:<nowiki>#</nowiki> service vsftpd restart

== Установка proFTPD в RHEL 7.x(CentOS 7.x) ==
1) Инсталлируем proftpd:
:<nowiki>#</nowiki> yum install -y proftpd proftpd-utils
2) Добавляем группу и пользователя '''''vftp''''', задаём пароль:
:<nowiki>#</nowiki> groupadd -g 510 vftp
:<nowiki>#</nowiki> useradd -g 510 -u 510 -c 'Virtual FTP User' -d /home/vftp -s /sbin/nologin vftp
:<nowiki>#</nowiki> passwd vftp
3) Создаём '''виртуальных пользователей''' сервиса ''ftp'' и директории:
:<nowiki>#</nowiki> /usr/bin/ftpasswd --passwd --file /etc/ftpd.passwd --name=ftpuser --shel=/sbin/nologin --home=/opt/ftp --uid=510 --gid=510
:<nowiki>#</nowiki> mkdir -p /opt/ftp
:<nowiki>#</nowiki> chown -R vftp:vftp /opt/ftp
:<nowiki>#</nowiki> /usr/bin/ftpasswd --group --name=vftp --file=/etc/ftpd.group --gid=510 --member ftpuser
4) Комментируем(символ комментария — '''#''') в конфиге '''''/etc/proftpd.conf''''' следующие строки:
:::'''AuthPAMConfig proftpd'''
:::'''AuthOrder mod_auth_pam.c* mod_auth_unix.c'''
5) Редактируем(''добавляем''/''изменяем'') в конфиге '''''/etc/proftpd.conf''''' следующие строки:
:::'''AuthUserFile /etc/ftpd.passwd'''
:::'''AuthGroupFile /etc/ftpd.group'''
:::'''AuthOrder mod_auth_file.c'''
:::'''RequireValidShell off'''
:::'''AuthPAMConfig proftpd'''
6) Проверяем синтаксис конфига:
:<nowiki>#</nowiki> proftpd -t
7) Настраиваем автозапуск сервиса, стартуем сервис, проверяем статус:
:<nowiki>#</nowiki> systemctl enable proftpd.service
:<nowiki>#</nowiki> systemctl start proftpd.service
:<nowiki>#</nowiki> systemctl status proftpd.service
8) Проверяем доступность ftp сервиса, подключившись под пользователем/паролем ftpuser/ftpuser

== Ссылки ==
[http://www.andrewblog.ru/ustanovka-i-nastrojka-ftp-servera-na-freebsd-11-0-release-praktika-ispolzovaniya-proftpd/ Настройка proFTPD на FreeBSD 11] 
[https://habrahabr.ru/sandbox/26850/ Настройка ProFTPd для хостинга] 
[https://kamaok.org.ua/?p=97 Установка и настройка ProFTPD с авторизацией виртуальных пользователей на CentOS] 
[https://www.howtoforge.com/proftpd-centos-7 proFTPD на CentOS 7] 
[http://tnadm.blogspot.ru/2012/08/ftp-proftpd-ubuntu-1204-lts.html FTP-сервер (ProFTPd) на Ubuntu 12.04 LTS] 
[http://thenest.ru/nastrojjka-proftpd-dlya-raboty-s-virtualnymi-polzovatelyami-i-proizvolnymi-direktoriyami/ Настройка proftpd для работы с виртуальными пользователями и произвольными директориями] 
[http://10.160.22.182:9009/scripts/Var_Scripts/blob/master/AutoInstall_FTP.sh Скрипт автоматической инсталляции и настройки ftp]

Sed

2017-11-02T12:24:05Z

Vaal: Полностью отредактировал статью

== Введение ==

Команда [[sed]] - это редактор потока данных ('''S'''tream '''ED'''itor) для автоматического редактирования текстов. "''Редактор потока''" — в том смысле, что может редактировать входящий поток данных непрерывно, скажем, в составе программного канала (''pipe''). ''Автоматически'' — это значит, что, как только вы зададите правила редактирования, дальнейшее происходит без вашего утомительного участия. Другими словами, редактор [[sed]] не является ''интерактивным''.

Программа [[sed]] сложнее, чем те команды, что мы уже успели рассмотреть в предыдущих статьях. В её составе арсенал собственных команд, поэтому, чтобы избежать тавтологии и путаницы, в этой статье команда [[sed]] впредь будет именоваться "''программой''" или "''редактором''", а команды редактора [[sed]] — просто ''командами''. 
Программа [[sed]] способна выполнять сложные задания, и нужно потратить время, чтобы научиться эти задания формулировать. Но наряду со сложными действиями, у команды [[sed]] есть простые, но весьма полезные возможности, освоить которые не труднее, чем прочие команды UNIX. Не позволяйте себе из-за сложности освоения всей программы, отказываться от её простых аспектов. Мы начнем от простого к сложному, так что вы всегда сможете понять, где следует остановиться.

=== Команда s — substitution (замена) ===

Программа [[sed]] имеет множество собственных ''команд''. Большинство пользователей знают только команду '''s''', и этого вполне хватает, чтобы работать с редактором [[sed]]. Команда '''s''' заменяет ''ОБРАЗЕЦ'' на ''ЗАМЕНУ'':

<source lang="bash">sed s/ОБРАЗЕЦ/ЗАМЕНА/</source> 
<source lang="bash">
$ echo день | sed s/день/ночь/
ночь
</source>
Проще не бывает. А вот пример с вводом из файла zar.txt:
По утрам он делал зарядку.
Молния — электрический заряд.
<source lang="bash">
$ sed s/заряд/разряд/ zar.txt
По утрам он делал разрядку.
Молния — электрический разряд.
</source>

Я не брал выражение ''s/ОБРАЗЕЦ/ЗАМЕНА/'' в кавычки, так как данный пример не нуждается в кавычках, но если бы в нём ''присутствовали метасимволы'', то кавычки были бы '''обязательны'''. Чтобы не ломать себе каждый раз голову, и не ошибиться ненароком, всегда ставьте кавычки, лучше более "''сильные''" одинарные(' '), это хорошая привычка. Кашу маслом не испортишь. Я тоже во всех последующих примерах не буду манкировать кавычками.

Как мы видим, заменяющая команда '''s''' имеет четыре составляющих:

'''''s''''' — сама команда
'''''/.../.../''''' — разделитель
'''''ОБРАЗЕЦ''''' — образец для поиска и последующей замены
'''''ЗАМЕНА''''' — выражение, которое заменит собой ''ОБРАЗЕЦ'', если таковой будет найден!

'''Прямой слэш''' ('''/''') используется в качестве разделителя по традиции, так как предок программы [[sed]] — редактор '''ed''' использует их (как и редактор [[Vim|vi]]). В некоторых случаях такой разделитель весьма неудобен, например, когда надо менять пути (''path'') к директориям, которые тоже содержат '''прямой слэш''' ('''/'''usr'''/'''local'''/'''bin). В этом случае приходится разделять прямые слэши обратными:
<source lang="bash">
sed 's/\/usr\/local\/bin/\/common\/bin/'
</source>
Это называется "'''частокол'''" и выглядит весьма уродливо, а главное, непонятно. 
Уникальность программы [[sed]] в том, что она позволяет использовать любой разделитель, например знак '''подчёркивания''':
<source lang="bash">
$ echo день | sed s_день_ночь_
ночь
</source>
или '''двоеточие''':
<source lang="bash">
$ echo день | sed s:день:ночь:
ночь
</source>
Если в поисках разделителя, который вам нравится, вы получаете сообщение "'''''незавершённая команда `s' '''''", значит этот ''символ'' не годится в качестве разделителя, или вы просто забыли поставить один-два разделителя.
В этой статье я вынужден использовать традиционный разделитель ('''/''') чтобы не сбивать читателя с толку, но в случае необходимости стану использовать в качестве разделителя '''тильду''' ('''~''').

=== Регулярные выражения (РВ) ===
('''Regular expressions''', '''regexp''', '''RE''')

Тема регулярных выражений настолько обширна, что ей посвящены целые книги (смотри ссылки в конце статьи). Тем не менее, говорить всерьёз о редакторе [[sed]], не применяя регулярных выражений, также непродуктивно, как разговаривать о тригонометрии при помощи счётных палочек. Поэтому необходимо рассказать хотя бы о тех регулярных выражениях, которые часто используются с программой [[sed]].

'''с''' — или любая другая буква. Большинство букв, цифр и прочих неспециальных символов считаются регулярными выражениями, представляющими сами себя.

'''*''' — Астериск, следующий за каким-либо символом или регулярным выражением, означает любое число (в том числе и нулевое) повторов этого символа или регулярного выражения.

'''\+''' — Означает один или более повтор символа или регулярного выражения.

'''\?''' — Означает ни одного или один повтор.

'''\{i\}''' — Означает ровно '''i''' повторов.

'''\{i,j\}''' — Число повторов находится в интервале от '''i''' до '''j''' включительно.

'''\{i,\}''' — Число повторов больше или равно '''i'''.

'''\{,j\'''} — Число повторов меньше или равно '''j'''.

'''$RE\''') — Запомнить регулярное выражение или его часть с целью дальнейшего использования как единое целое. Например, '''\(а-я$*''' будет искать любое сочетание любого количества (в том числе и нулевого) строчных букв.

'''.''' — Означает любой символ, в том числе символ новой строки.

'''^''' — Означает нулевое выражение в начале строки. Другими словами, то, перед чем стоит этот знак, должно появляться в начале строки. Например, '''^#include''' будет искать строки, начинающиеся с #include.

'''$''' — То же, что и предыдущее, только относится к концу строки.

'''[СПИСОК]''' — Означает любой символ из ''СПИСКА''. Например, '''[aeiou]''' будет искать любую английскую гласную букву.

'''[^СПИСОК]''' — Означает любой символ, кроме тех, что в списке. Например, '''[^aeiou]''' будет искать любую английскую согласную. Примечание: ''СПИСОК'' может быть '''интервалом''', например '''[а-я]''', что будет означать любую строчную букву. Если нужно включить в ''СПИСОК'' ''']''' (''квадратную скобку'') укажите её в списке первой; если нужно включить в ''СПИСОК'' '''-''' (''дефис''), то укажите его в списке первым или последним.

'''RE1\|RE2''' — Означает '''РВ1''' или '''РВ2'''.

'''RE1RE2''' — Означает объединение регулярных выражений '''РВ1''' и '''РВ2'''.

'''\n''' — Означает символ новой строки.

'''\$; \*; \.; \[; \\; \^''' — Означают соответственно: ''$; *; .; [; \; ^''

'''''Внимание:''''' Остальные условные обозначения на основе '''обратного слэша''' ('''\'''), принятые в языке '''С''', не поддерживаются программой [[sed]].

'''\1 \2 \3 \4 \5 \6 \7 \8 \9''' — Означает соответствующую по счёту часть регулярного выражения, запомненную при помощи знаков '''$''' и '''$'''.

'''''Несколько примеров:'''''

'''abcdef''' — Означает '''abcdef'''

'''a*b''' — Означает ноль или любое количество букв ''''''а и одна буква '''b'''. Например, '''aaaaaab'''; '''ab'''; или '''b'''.

'''a\?b''' — Означает '''b''' или '''ab'''

'''a\+b\+''' — Означает одну или больше букв '''а''' и одну или больше букв '''b'''. Например: '''ab'''; '''aaaab'''; '''abbbbb'''; или '''aaaaaabbbbbbb'''.

'''.*''' — Означает '''все символы на строке''', на '''всех строках''', ''включая пустые''.

'''.\+''' — Означает '''все символы на строке''', но '''только на строках''', ''содержащих'' хотя бы ''один символ'''. '''Пустые строки''' ''не соответствуют'' данному регулярному выражению.

'''^main.*(.*)''' — Будет искать строки, начинающиеся со слова '''main''', а также имеющие в своём составе '''открывающую и закрывающие скобки''', причём ''перед и после открывающей скобки'' может находиться любое количество символов (а может и не находиться).

'''^#''' — Будет искать строки, начинающиеся со знака '''#''' (например ''комментарии'').

'''\\$''' — Будет искать строки, заканчивающиеся '''обратным слэшем''' ('''\''').

'''[a-zA-Z_]''' — Любые '''буквы''' или '''цифры'''

'''[^ ]\+''' — Означает '''один''' или '''любое''' количество '''любых символов''', кроме '''пробела''' и '''табуляции'''. Обычно имеется в виду '''слово'''(В квадратной скобке, кроме символа '''^''', содержится ещё '''пробел''' и '''табуляция''').

'''^.*A.*$''' — Означает заглавную букву '''А''' точно в ''середине строки''.

'''A.\{9\}$''' — Означает заглавную букву '''А''', точно '''десятую по счёту от конца строки'''.

'''^.\{,15\}A''' — Означает заглавную букву '''А''', точно '''шестнадцатую по счёту от начала строки'''.

Теперь, когда мы познакомились с некоторыми регулярными выражениями, вернемся к команде '''s''' редактора [[sed]].

Использование символа '''&''', когда ''ОБРАЗЕЦ'' неизвестен
"Как это неизвестен?", — спросите вы — "Ты разве не знаешь, что хочешь заменить?" Отвечу: я хочу взять в скобки любые цифры, найденные в тексте. Как это сделать? Ответ: применить символ '''&'''.

Символ '''&''' ('''амперсанд'''), будучи помещён в состав ''ЗАМЕНЫ'', означает '''любой найденный в тексте''' ''ОБРАЗЦЕ''. Например:
<source lang="bash">
$ echo 1234 | sed 's/[0-9]*/(&)/'
(1234)
</source>
Звёздочка ('''астериск''') после интервала '''[0-9]''' нужна чтобы заменены были все цифры, встретившиеся в ''ОБРАЗЦЕ''. Без неё получилось бы:
<source lang="bash">
$ echo 1234 | sed 's/[0-9]/(&)/'
(1)234
</source>
То есть в качестве ''ОБРАЗЦА'' взята была первая же найденная цифра.

Вот пример со вполне осмысленной нагрузкой: составим файл formula.txt:

a+432-10=n

и применим к нему команду:
<source lang="bash">
$ sed 's/[0-9]*-[0-9]*/(&)/' formula.txt
a+(432-10)=n
</source>
Математическая формула приобрела однозначный смысл.

Ещё символ '''амперсанда''' ('''&''') можно использовать для удвоения ''ОБРАЗЦА'':
<source lang="bash">
$ echo 123 | sed "s/[0-9]*/& &/"
123 123
</source>
Тут есть одна тонкость. Если мы чуть усложним пример:
<source lang="bash">
$ echo "123 abc" | sed "s/[0-9]*/& &/"
123 123 abc
</source>
как и следовало ожидать, удваиваются только цифры, так как в ''ОБРАЗЦЕ'' нет букв. Но если мы поменяем части текста местами:
<source lang="bash">
$ echo "abc 123" | sed "s/[0-9]*/& &/"
abc 123
</source>
то никакого удвоения цифр не получится. Это особенность регулярного выражения '''[0-9]*''' — оно ищет соответствия только в первом символе строки. Если мы хотим удвоения цифр, где бы они ни находились, нужно доработать регулярное выражение в ''ЗАМЕНЕ'':
<source lang="bash">
$ echo "abc defg 123" | sed "s/[0-9][0-9]*/& &/"
abc defg 123 123
</source>
тогда цифры будут удваиваться, независимо от количества предшествующих "слов".

Использование условных знаков '''$''', '''$''' и '''\1''' для обработки части ''ОБРАЗЦА''.
Условные знаки '''$''' и '''$''' (''escaped parentheses'') применяются для запоминания части регулярного выражения.

Условный знак '''\1''' означает первую запомненную часть, '''\2''' — вторую, и так далее, вплоть до девяти запомненных частей (больше программа не поддерживает). Разберём пример:
<source lang="bash">
$ echo abcd123 | sed 's/$[a-z]*$.*/\1/'
abcd
</source>
Здесь '''$[a-z]*$''' означает, что программа должна запомнить все буквенные символы в любом количестве; '''.*''' означает любое количество символов после первой запомненной части; а '''\1''' означает , что мы хотим видеть только первую запомненную часть. Так и есть: в выводе программы мы видим только буквы и никаких цифр.

Для того, чтобы ''поменять'' слова местами, нужно ''запомнить'' два суб-''ОБРАЗЦА'', а потом поменять их местами:
<source lang="bash">
$ echo глупый пингвин |sed 's/$[а-я]*$ $[а-я]*$/\2 \1/'
пингвин глупый
</source>
Здесь '''\2''' означает второй суб-''ОБРАЗЕЦ'', а '''\1''' — первый. Обратите внимание на интервал между первым выражением '''$[а-я]*$''' и вторым выражением '''$[а-я]*$'''. Он необходим, чтобы были найдены два слова.

Знак '''\1''' вовсе не обязан быть только в ''ЗАМЕНЕ'', он может присутствовать также и в ''ОБРАЗЦЕ'', например, когда мы хотим '''удалить''' ''дубликаты слов'':
<source lang="bash">
$ echo пингвин пингвин | sed 's/$[а-я]*$ \1/\1/'
пингвин
</source>

=== Модификаторы замены команды s ===

Модификаторы замены ставятся после последнего разделителя. Эти модификаторы определяют действия программы в случае, если в строке нашлось более одного совпадения с ''ОБРАЗЦОМ'', и каким образом производить замену.

'''Модификатор /g'''

Глобальная замена (Global replacement)

Программа [[sed]], как и большинство утилит UNIX, при работе с файлами считывают по одной строке. Если мы приказываем заменить слово, программа заменит только первое совпавшее с ''ОБРАЗЦОМ'' слово на данной строке. Если мы хотим изменить каждое слово, совпавшее с ''ОБРАЗЦОМ'', то следует ввести модификатор '''/g'''.

Без модификатора '''/g''':
<source lang="bash">
$ echo кот этот, был самый обычный кот | sed 's/кот/котёнок/'
котёнок этот, был самый обычный кот
</source>
Редактор заменил только первое совпавшее слово.

А теперь с модификатором глобальной замены:
<source lang="bash">
$ echo кот этот, был самый обычный кот | sed 's/кот/котёнок/g'
котёнок этот, был самый обычный котёнок
</source>

'''Все''' совпадения в данной строке были заменены.

А если нужно изменить '''все слова''', скажем взять их в скобки? Тогда на помощь снова придут регулярные выражения. Чтобы выбрать все буквенные символы, как верхнего, так и нижнего регистра, можно воспользоваться конструкцией '''[А-Яа-я]''', но в неё не попадут такие слова как "что-то" или "с'езд". Гораздо удобнее конструкция '''[^ ]*''', которая соответствует всем символам, кроме '''пробела'''. Итак:
<source lang="bash">
$ echo глупый пингвин робко прячет | sed 's/[^ ]*/(&)/g'
(глупый) (пингвин) (робко) (прячет)
</source>

'''Как выбрать нужное совпадение из нескольких'''

Если не применять модификаторов, то программа [[sed]] заменит только первое совпавшее с ''ОБРАЗЦОМ'' слово. Если применить модификатор ''/g'', то программа заменит ''каждое совпавшее слово''. 
А как можно выбрать одно из совпадений, если их несколько на строке? — При помощи уже знакомых нам условных знаков '''$''' и '''$''' запомнить суб-''ОБРАЗЦЫ'' и выбрать нужный при помощи знаков '''\1''' - '''\9'''.
<source lang="bash">
$ echo глупый пингвин | sed 's/$[а-я]*$ $[а-я]*$/\2 /'
пингвин
</source>
В этом примере мы запомнили оба слова, и, поставив второе (пингвин) на первое место, первое (глупый) удалили, поставив в секции ''ЗАМЕНЫ'' вместо него '''пробел'''. Если мы поставим вместо '''пробела''' какое-либо слово, то оно заменит первое (глупый):
<source lang="bash">
$ echo глупый пингвин | sed 's/$[а-я]*$ $[а-я]*$/\2 умный /'
пингвин умный
</source>

'''Числовой модификатор'''

Это одно/двух/трёх-значное число, которое ставится после последнего разделителя и указывает, какое по счёту совпадение подлежит замене.
<source lang="bash">
$ echo очень глупый пингвин | sed 's/[а-я]*/хороший/2'
очень хороший пингвин
</source>

В этом примере каждое слово является совпадением, и мы указали редактору, какое по счёту слово мы хотим заменить, поставив модификатор 2 после секции ''ЗАМЕНЫ''.

Можно комбинировать цифровой модификатор с модификатором '''/g'''. Если нужно оставить неизменным первое слово, а второе и последующие заменить на слово "(удалено)", то команда будет такая:
<source lang="bash">
$ echo очень глупый пингвин | sed 's/[а-я]*/(удалено)/2g'
очень (удалено) (удалено)
</source>

Если нужно действительно удалить все последующие совпадения, кроме первого, то в секции ''ЗАМЕНЫ'' следует поставить '''пробел''':
<source lang="bash">
$ echo очень глупый пингвин | sed 's/[а-я]*/ /2g'
очень
</source>

Или вовсе ничего не ставить:
<source lang="bash">
$ echo очень глупый пингвин | sed 's/[^ ]*//2g'
очень
</source>

Числовой модификатор может быть любым целым числом от '''1''' до '''512'''. Например, если нужно поставить '''двоеточие''' ''после'' '''80''' символа ''каждой строки'', то поможет команда:
<source lang="bash">
$ sed 's/./&:/80' имя_файла
</source>

'''Модификатор /p - выдавать на стандартный выход (печатать - print)'''

Программа [[sed]] и так по умолчанию выдаёт результат на стандартный выход (например экран монитора). Этот модификатор применяется только с опцией '''sed -n''', которая как раз блокирует вывод результата на экран.

'''Модификатор /w'''

Позволяет записывать результаты обработки текста в указанный файл:
<source lang="bash">
$ sed 's/ОБРАЗЕЦ/ЗАМЕНА/w имя_файла
</source>

'''Модификатор /e (расширение GNU)'''

Позволяет указать команду шелла (не программы sed) в качестве ''ЗАМЕНЫ''. Если соответствие ''ОБРАЗЦУ'' будет найдено, то оно будет заменено на вывод указанной в секции ''ЗАМЕНЫ'' команды. Пример:
<source lang="bash">
$ echo ночь | sed 's/ночь/echo день/e'
день
</source>

'''Модификаторы /I и /i (расширение GNU)'''

Делают процесс замены нечувствительным к регистру символов.
<source lang="bash">
$ echo Night | sed 's/night/day/i'
day
</source>

'''Комбинации модификаторов'''

Модификаторы можно комбинировать, когда это имеет смысл. При этом следует ставить модификатор w последним.

''Условные обозначения (расширение GNU'')
Их всего пять:

'''\L''' — переводит символы ''ЗАМЕНЫ'' в нижний регистр
'''\l''' — переводит следующий символ ''ЗАМЕНЫ'' в нижний регистр
'''\U''' — переводит символы ''ЗАМЕНЫ'' в верхний регистр
'''\u''' — переводит следующий символ ''ЗАМЕНЫ'' в верхний регистр
'''\E''' — отменяет перевод, начатый '''\L''' или '''\U'''
По очевидным причинам эти условные обозначения применяются по одиночке. Например:
<source lang="bash">
$ echo глупый пингвин | sed 's/глупый/\u&/'
Глупый пингвин
</source>

или:
<source lang="bash">
$ echo маленький щенок | sed 's/[а-я]*/\u&/2'
маленький Щенок
</source>

Мы рассмотрели почти все аспекты команды '''s''' редактора [[sed]]]. Теперь настала очередь рассмотреть опции этой программы.

== Опции программы sed ==

Программа имеет на удивление мало опций. (Что несколько компенсирует избыток команд, модификаторов и прочих функций). Кроме общеизвестных опций '''--help''' ('''-h''') и '''--version''' ('''-V'''), которые мы рассматривать не будем, их всего три:

'''Опция -e'''
''--expression=набор_команд''

Один из способов выполнения нескольких команд - применение опции ''-e''. Например:
<source lang="bash">
sed -e 's/a/A/' -e 's/b/B/' имя_файла
</source>
Все предыдущие примеры в этой статье не требовали применения опции '''-e''' только потому, что содержали одну команду. Мы могли поставить в примерах опцию '''-e''', это ничего бы не изменило.

'''Опция -f'''
Если требуется выполнить большое количество команд, то удобнее записать их в файл и применить опцию '''-f''':
<source lang="bash">
sed -f sedscript имя-файла
</source>

'''Sedscript''' здесь — имя файла, содержащего команды. Этот файл называется скриптом программы [[sed]] (далее просто скрипт). Каждая команда скрипта должна занимать отдельную строку. Например:

# комментарий — Этот скрипт изменит все строчные гласные буквы на заглавные
s/a/A/g
s/e/E/g
s/i/I/g
s/o/O/g
s/u/U/g

Назвать скрипт можно как угодно, важно не путать файл скрипта с обрабатываемым файлом.

'''Опция -n'''
Программа '''sed -n''' не выводит ничего на стандартный выход. Чтобы получить вывод нужно специальное указание. Мы уже познакомились с модификатором '''/p''', при помощи которого можно дать такое указание. Вспомним файл zar.txt:
<source lang="bash">
$ sed 's/1-9/&/p' zar.txt
По утрам он делал зарядку.
Молния - электрический заряд.
</source>

Так как совпадений с ''ОБРАЗЦОМ'' не найдено (в файле нет цифр), то команда '''s''' с модификатором '''/p''' и знаком '''&''' в качестве ''ЗАМЕНЫ'' (напомню, что '''амперсанд''' означает сам ''ОБРАЗЕЦ''), работает как команда [[cat]].

Если ''ОБРАЗЕЦ'' будет найден в файле, то строки, содержащие ''ОБРАЗЕЦ'', будут удвоены:
<source lang="bash">
$ sed 's/зарядку/&/p' zar.txt
По утрам он делал зарядку.
По утрам он делал зарядку.
Молния - электрический заряд.
</source>
Теперь добавим опцию '''-n''':
<source lang="bash">
$ sed -n 's/зарядк/&/p' zar.txt
По утрам он делал зарядку.
</source>
Теперь наша программа работает, как команда [[grep]] — возвращает только строки, содержащие ''ОБРАЗЕЦ''.

== Выбор нужных элементов редактируемого текста ==

Используя лишь одну команду '''s''', мы убедились в необыкновенно широких возможностях редактора [[sed]]. А ведь всё, что он делает, сводится к поиску и замене. Причём в процессе работы [[sed]] редактирует каждую строку поодиночке, не обращая внимания на другие. Было бы удобно ограничить круг строк, подлежащих изменению, например:
* Выбирать строки по номерам
* Выбирать строки в некотором диапазоне номеров
* Выбирать только строки, содержащие некое выражение
* Выбирать только строки между некоторыми выражениями
* Выбирать только строки от начала файла и до некоторого выражения
* Выбирать только строки от некоторого выражения и до конца файла

Программа [[sed]] умеет всё это и даже больше. Любая команда редактора [[sed]] может применяться адресно, в некотором диапазоне адресов, или с вышеперечисленными ограничениями круга строк. Адрес или ограничение должны непосредственно предшествовать команде:
<source lang="bash">
sed 'адрес/ограничение команда'
</source>

'''Выбор строк по номерам'''

Это самый простой случай. Просто указываем номер нужной строки перед командой:
<source lang="bash">
$ sed '4 s/[а-я]*//i' gumilev.txt
Какая странная нега
В ранних сумерках утра,
В таянии вешнего снега,
всём, что гибнет и мудро.
</source>

Или:
<source lang="bash">
$ sed '3 s/В/(В)/' gumilev.txt
Какая странная нега
В ранних сумерках утра,
(В) таянии вешнего снега,
Во всём, что гибнет и мудро.
</source>

'''Выбор строк в диапазоне номеров'''

Диапазон указывается, как не удивительно, через запятую:
<source lang="bash">
$ sed '2,3 s/В/(В)/' gumilev.txt
Какая странная нега
(В) ранних сумерках утра,
(В) таянии вешнего снега,
Во всём, что гибнет и мудро.
</source>

Если нужно указать диапазон до последней строки файла, а вы не знаете, сколько в нём строк, то воспользуйтесь знаком '''$''':
<source lang="bash">
$ sed '2,$ s/в/(в)/i' gumilev.txt
Какая странная нега
(в) ранних сумерках утра,
(в) таянии вешнего снега,
(в)о всём, что гибнет и мудро.
</source>

'''Выбор строк, содержащих некое выражение'''

Искомое выражение заключается в прямые слэши ('''/''') и ставится перед командой:
<source lang="bash">
$ sed '/утра/ s/в/(в)/i' gumilev.txt
Какая странная нега
(в) ранних сумерках утра,
В таянии вешнего снега,
Во всём, что гибнет и мудро.
</source>

'''Выбор строк в диапазоне между двумя выражениями'''

Также как и в случае с номерами строк, диапазон задается через запятую:
<source lang="bash">
$ sed '/утра/,/мудро/ s/в/(в)/i' gumilev.txt
Какая странная нега
(в) ранних сумерках утра,
(в) таянии вешнего снега,
(в)о всём, что гибнет и мудро.
</source>

'''Выбор строк от начала файла и до некоего выражения'''
<source lang="bash">
$ sed '1,/снега/ s/в/(в)/i' gumilev.txt
Какая странная нега
(в) ранних сумерках утра,
(в) таянии вешнего снега,
Во всём, что гибнет и мудро.
</source>

'''Выбор строк от некоего выражения и до конца файла'''
<source lang="bash">
$ sed '/снега/,$ s/в/(в)/i' gumilev.txt
Какая странная нега
В ранних сумерках утра,
(в) таянии вешнего снега,
(в)о всем, что гибнет и мудро.
</source>

== Другие команды редактора sed ==

'''Команда d (delete)'''

Удаляет из стандартного вывода указанные строки:
<source lang="bash">
$ sed '2 d' gumilev.txt
Какая странная нега
В таянии вешнего снега,
Во всем, что гибнет и мудро.
</source>

Причём чаще пишут проще (без пробела):
<source lang="bash">
sed '2d' gumilev.txt
</source>
Все, что было сказано в предыдущем разделе о адресации строк, справедливо и для команды '''d''' (как и для почти всех команд редактора [[sed]]).

При помощи команды '''d''' удобно выбросить ненужную "шапку" какого-нибудь почтового сообщения:
<source lang="bash">
$ sed '1,/^$/ d' имя_файла
</source>
(Удалить строки с первой и до первой пустой строки).

Избавится от комментариев в конфигурационном файле:
<source lang="bash">
$ sed '/^#/ d' /boot/grub/menu.lst
</source>

И мало ли, где нужно удалить лишние строчки!

'''Команда p (print)'''

Английское слово "print" переводится как "печатать", что в русском языке ассоциируется с принтером, или, по крайней мере, с клавиатурой. На самом же деле, слово это в английском контексте зачастую означает просто вывод на экран монитора. Так что команда '''p''' ничего не печатает, а просто выводит на экран указанные строки.

Будучи применённой сама по себе, команда '''p''' удваивает строки в выводе (ведь программа [[sed]] по умолчанию выводит строку на экран, а команда '''p''' выводит ту же строку вторично).
<source lang="bash">
$ echo у меня есть кот | sed 'p'
у меня есть кот
у меня есть кот
</source>

Этому свойству находится применение, например удвоить пустые строки для улучшения вида текста:
<source lang="bash">
$ sed '/^$/ p имя_файла
</source>

Но истинное своё лицо команда '''p''' раскрывает в сочетании с опцией '''-n''', которая, как вы помните, запрещает вывод строк на экран. Комбинируя опцию '''-n''' с командой '''p''', можно получить в выводе только нужные строки.

Например, просмотреть строки с первой по десятую:
<source lang="bash">
$ sed -n '1,10 p' имя_файла
</source>

Или только комментарии:
<source lang="bash">
$ sed -n '/^#/ p' /boot/grub/menu.lst
# GRUB configuration file '/boot/grub/menu.lst'.
# generated by 'grubconfig'. Вск 23 Мар 2008 21:45:41
#
# Start GRUB global section
# End GRUB global section
# Linux bootable partition config begins
# Linux bootable partition config ends
# Linux bootable partition config begins
# Linux bootable partition config ends
</source>

Что весьма напоминает работу программы [[grep]], с чем мы уже сталкивались, когда говорили об опции '''-n''' с модификатором '''/p'''. Но, в отличие от команды [[grep]], редактор [[sed]] даёт возможность не только найти эти строки, но и изменить их, заменив, например, везде Linux на Unix:
<source lang="bash">
$ sed -n '/^#/ p' /boot/grub/menu.lst | sed 's/Linux/Unix/'
# GRUB configuration file '/boot/grub/menu.lst'.
# generated by 'grubconfig'. Вск 23 Мар 2008 21:45:41
#
# Start GRUB global section
# End GRUB global section
# Unix bootable partition config begins
# Unix bootable partition config ends
# Unix bootable partition config begins
# Unix bootable partition config ends
</source>

'''Команда !'''

Иногда нужно бывает редактировать все строки, кроме тех, что соответствуют ''ОБРАЗЦУ'', либо выбору. Символ восклицательного знака ('''!''') инвертирует выбор. Например удалим все строки, кроме второй из четверостишия Гумилева:
<source lang="bash">
$ sed '2 !d' gumilev.txt
В ранних сумерках утра,
</source>

Или выберем все строки, кроме комментариев, из файла /boot/grub/menu.lst:
<source lang="bash">
$ sed -n '/^#/ !p' /boot/grub/menu.lst
default 1
timeout 20
gfxmenu (hd0,3)/boot/message
title SuSe on (/dev/hda3)
root (hd0,2)
kernel /boot/vmlinuz root=/dev/hda3 ro vga=773 acpi=off
title Linux on (/dev/hda4)
root (hd0,3)
kernel /boot/vmlinuz root=/dev/hda4 ro vga=0x317
</source>

'''Команда q (quit)'''

Команда '''q''' прекращает работу программы [[sed]] после указанной строки. Это удобно, если нужно прекратить редактирование после достижения определенного места в тексте:
<source lang="bash">
$ sed '11 q' имя_файла
</source>

Эта команда закончит работу по достижению 11-й строки.

Команда '''q''' — одна из немногих команд [[sed]], не принимающих диапазонов строк. Не может же команда прекратить работу 10 раз подряд, если мы введём:
<source lang="bash">
sed '1,10 q'
</source>
Абсурд!

'''Команда w (write)'''

Подобно модификатору '''w''' команды '''s''', эта команда позволяет записать вывод программы в файл:
<source lang="bash">
$ sed -n '3,$ w gum.txt' gumilev.txt
</source>

Мы получим файл gum.txt, содержащий две последние строки четверостишия Гумилёва из файла gumilev.txt. Причём, если такой файл уже существует, то будет перезаписан. Если не ввести опцию '''-n''', то программа, кроме создания файла gum.txt, еще и выведет на экран все содержание файла gumilev.txt.

Для работы в командной строке, удобнее пользоваться обычным перенаправлением вывода ('''>''' или '''>>'''), но в [[sed]] скриптах, вероятно, команда '''w''' найдёт своё применение.

'''Команда r (read)'''

Эта команда не только прочтёт указанный файл, но и вставит его содержимое в нужное место редактируемого файла. Для выбора "нужного места" используется уже знакомая нам адресация (по номерам строк, по выражениям, и проч.). Пример:
<source lang="bash">
$ echo Из стихотворения Гумилева: | sed 'r gumilev.txt'
Из стихотворения Гумилева:
Какая странная нега
В ранних сумерках утра,
В таянии вешнего снега,
Во всем, что гибнет и мудро.
</source>

'''Команда ='''

Выдаст номер указанной строки:
<source lang="bash">
$ sed '/снега/=' gumilev.txt
Какая странная нега
В ранних сумерках утра,
3
В таянии вешнего снега,
Во всём, что гибнет и мудро.
</source>

Или:
<source lang="bash">
$ sed -n '/снега/=' gumilev.txt
3
</source>

Команда принимает только один адрес, не принимает интервалов.

'''Команда y'''

Эта команда заменяет символы из секции ''ОБРАЗЕЦ'' символами секции ''ЗАМЕНА'', работая как программа ''tr''.
<source lang="bash">
$ echo Автомобиль — наследие прошлого | sed 'y/Авто/Паро/'
Паромобиль — наследие прошлого
</source>
Команда '''y''' работает, только если количество символов в ''ОБРАЗЦЕ'' равно количеству символов в ''ЗАМЕНЕ''.

== Скрипты программы sed ==

Для того, чтобы пользоваться редактором [[sed]] как полноценным текстовым редактором, необходимо освоить составление скриптов [[sed]]. Программа [[sed]] имеет собственный несложный язык программирования, позволяющий составлять скрипты, способные творить чудеса.

Эта статья не может вместить описания скриптов [[sed]], как и её автор не ставит себе задачу освоение языка программирования [[sed]]. В этой статье я делал акцент на использование редактора [[sed]] в командной строке, имея прицел на использование его в качестве фильтра в программных каналах (''pipes''). По этой причине я опустил многочисленные команды [[sed]], применяющиеся только в его скриптах.

Существует множество любителей редактора [[sed]], и множество статей на тему скриптописания, в том числе и в Рунете. Так что для заинтересовавшихся этой замечательной программой не составит труда пополнить свои знания.

=== Программа sed и символы кириллицы ===

Как видно из примеров в этой статье, программа [[sed]] на правильно русифицированной системе свободно владеет "великим и могучим" языком.

== Резюме программы sed ==

Программа [[sed]] — это многофункциональный редактор потока данных, незаменимый для:
* Редактирования больших текстовых массивов
* Редактирования файлов любой величины, когда последовательность редактирующих действий слишком сложна
* Редактирования данных по мере их поступления, в том числе в режиме реального времени — то есть в случаях, когда затруднительно или вовсе невозможно использовать интерактивные текстовые редакторы.

Для освоения программы [[sed]] в полном объёме потребуются недели или даже месяцы работы, так как для этого необходимо:

* Изучить регулярные выражения
* Научиться писать скрипты [[sed]], освоив несложный язык программирования, применяющийся в этих скриптах

С другой стороны, освоить несколько наиболее употребительных команд редактора [[sed]] не сложнее, чем любую команду UNIX; надеюсь, данная статья поможет вам в этом.

== Таблица соответствия спецсимволов ==
Использование '''HEX-16''' позволяет вставлять спецсимволы
{| class="wikitable"
|-
! '''Символ в ASCII''' !! '''Соответствие в HEX-16''' !! '''Символ в ASCII''' !! '''Соответствие в HEX-16'''
|-
| style="text-align:center;" | '''!''' || style="text-align:center;" | \x21 || style="text-align:center;" | '''"''' || style="text-align:center;" | \x22
|-
| style="text-align:center;" | '''#''' || style="text-align:center;" | \x23 || style="text-align:center;" | '''$''' || style="text-align:center;" | \x24
|-
| style="text-align:center;" | '''%''' || style="text-align:center;" | \x25 || style="text-align:center;" | '''&''' || style="text-align:center;" | \x26
|-
| style="text-align:center;" | ''' ' ''' || style="text-align:center;" | \x27 || style="text-align:center;" | '''(''' || style="text-align:center;" | \x28
|-
| style="text-align:center;" | ''')''' || style="text-align:center;" | \x29 || style="text-align:center;" | '''*''' || style="text-align:center;" |\x2A
|-
| style="text-align:center;" | '''+''' || style="text-align:center;" | \x2B || style="text-align:center;" | ''',''' || style="text-align:center;" | \x2C
|-
| style="text-align:center;" | '''-''' || style="text-align:center;" | \x2D || style="text-align:center;" | '''.''' || style="text-align:center;" | \x2E
|-
| style="text-align:center;" | '''/''' || style="text-align:center;" | \x2F || style="text-align:center;" | '''0''' || style="text-align:center;" | \x30
|-
| style="text-align:center;" | '''1''' || style="text-align:center;" | \x31 || style="text-align:center;" | '''2''' || style="text-align:center;" | \x32
|-
| style="text-align:center;" | '''3''' || style="text-align:center;" | \x33 || style="text-align:center;" | '''4''' || style="text-align:center;" | \x34
|-
| style="text-align:center;" | '''5''' || style="text-align:center;" | \x35 || style="text-align:center;" | '''6''' || style="text-align:center;" | \x36
|-
| style="text-align:center;" | '''7''' || style="text-align:center;" | \x37 || style="text-align:center;" | '''8''' || style="text-align:center;" | \x38
|-
| style="text-align:center;" | '''9''' || style="text-align:center;" | \x39 || style="text-align:center;" | ''':''' || style="text-align:center;" | \x3A
|-
| style="text-align:center;" | ''';''' || style="text-align:center;" | \x3B || style="text-align:center;" | '''<''' || style="text-align:center;" | \x3C
|-
| style="text-align:center;" | '''=''' || style="text-align:center;" | \x3D || style="text-align:center;" | '''>''' || style="text-align:center;" | \x3E
|-
| style="text-align:center;" | '''?''' || style="text-align:center;" | \x3F || style="text-align:center;" | '''@''' || style="text-align:center;" | \x40
|-
| style="text-align:center;" | '''A''' || style="text-align:center;" | \x41 || style="text-align:center;" | '''B''' || style="text-align:center;" | \x42
|-
| style="text-align:center;" | '''C''' || style="text-align:center;" | \x43 || style="text-align:center;" | '''D''' || style="text-align:center;" | \x44
|-
| style="text-align:center;" | '''E''' || style="text-align:center;" | \x45 || style="text-align:center;" | '''F''' || style="text-align:center;" | \x46
|-
| style="text-align:center;" | '''G''' || style="text-align:center;" | \x47 || style="text-align:center;" | '''H''' || style="text-align:center;" | \x48
|-
| style="text-align:center;" | '''I''' || style="text-align:center;" | \x49 || style="text-align:center;" | '''J''' || style="text-align:center;" | \x4A
|-
| style="text-align:center;" | '''K''' || style="text-align:center;" | \x4B || style="text-align:center;" | '''L''' || style="text-align:center;" | \x4C
|-
| style="text-align:center;" | '''M''' || style="text-align:center;" | \x4D || style="text-align:center;" | '''N''' || style="text-align:center;" | \x4E
|-
| style="text-align:center;" | '''O''' || style="text-align:center;" | \x4F || style="text-align:center;" | '''P''' || style="text-align:center;" | \x50
|-
| style="text-align:center;" | '''Q''' || style="text-align:center;" | \x51 || style="text-align:center;" | '''R''' || style="text-align:center;" | \x52
|-
| style="text-align:center;" | '''S''' || style="text-align:center;" | \x53 || style="text-align:center;" | '''T''' || style="text-align:center;" | \x54
|-
| style="text-align:center;" | '''U''' || style="text-align:center;" | \x55 || style="text-align:center;" | '''V''' || style="text-align:center;" | \x56
|-
| style="text-align:center;" | '''W''' || style="text-align:center;" | \x57 || style="text-align:center;" | '''X''' || style="text-align:center;" | \x58
|-
| style="text-align:center;" | '''Y''' || style="text-align:center;" | \x59 || style="text-align:center;" | '''Z''' || style="text-align:center;" | \x5A
|-
| style="text-align:center;" | '''[''' || style="text-align:center;" | \x5B || style="text-align:center;" | '''\''' || style="text-align:center;" | \x5C
|-
| style="text-align:center;" | ''']''' || style="text-align:center;" | \x5D || style="text-align:center;" | '''^''' || style="text-align:center;" | \x5E
|-
| style="text-align:center;" | '''_''' || style="text-align:center;" | \x5F || style="text-align:center;" | '''`''' || style="text-align:center;" | \x60
|-
| style="text-align:center;" | '''a''' || style="text-align:center;" | \x61 || style="text-align:center;" | '''b''' || style="text-align:center;" | \x62
|-
| style="text-align:center;" | '''c''' || style="text-align:center;" | \x63 || style="text-align:center;" | '''d''' || style="text-align:center;" | \x64
|-
| style="text-align:center;" | '''e''' || style="text-align:center;" | \x65 || style="text-align:center;" | '''f''' || style="text-align:center;" | \x66
|-
| style="text-align:center;" | '''g''' || style="text-align:center;" | \x67 || style="text-align:center;" | '''h''' || style="text-align:center;" | \x68
|-
| style="text-align:center;" | '''i''' || style="text-align:center;" | \x69 || style="text-align:center;" | '''j''' || style="text-align:center;" | \x6A
|-
| style="text-align:center;" | '''k''' || style="text-align:center;" | \x6B || style="text-align:center;" | '''l''' || style="text-align:center;" | \x6C
|-
| style="text-align:center;" | '''m''' || style="text-align:center;" | \x6D || style="text-align:center;" | '''n''' || style="text-align:center;" | \x6E
|-
| style="text-align:center;" | '''o''' || style="text-align:center;" | \x6F || style="text-align:center;" | '''p''' || style="text-align:center;" | \x70
|-
| style="text-align:center;" | '''q''' || style="text-align:center;" | \x71 || style="text-align:center;" | '''r''' || style="text-align:center;" | \x72
|-
| style="text-align:center;" | '''s''' || style="text-align:center;" | \x73 || style="text-align:center;" | '''t''' || style="text-align:center;" | \x74
|-
| style="text-align:center;" | '''u''' || style="text-align:center;" | \x75 || style="text-align:center;" | '''v''' || style="text-align:center;" | \x76
|-
| style="text-align:center;" | '''w''' || style="text-align:center;" | \x77 || style="text-align:center;" | '''x''' || style="text-align:center;" | \x78
|-
| style="text-align:center;" | '''y''' || style="text-align:center;" | \x79 || style="text-align:center;" | '''z''' || style="text-align:center;" | \x7A
|-
| style="text-align:center;" | '''{''' || style="text-align:center;" | \x7B || style="text-align:center;" | '''<nowiki>|</nowiki>''' || style="text-align:center;" | \x7C
|-
| style="text-align:center;" | '''}''' || style="text-align:center;" | \x7D || style="text-align:center;" | '''~''' || style="text-align:center;" | \x7E
|-
| style="text-align:center;" | '''DEL''' || style="text-align:center;" | \x7F || ||
|}
Пример использования: 
Требуется: заменить '''"hello",''' на '''"hello world",'''
<source lang="bash">
sed 's/\x22hello\x22\x2C/\x22hello world\x22\x2C/g'
</source>

== Ссылки ==
За основу статьи взята информация с [http://open-club.ru/main/reading/HuMan_sed open-club.ru] 
Таблица символов [http://defindit.com/ascii.html ASCII] 
[https://habrahabr.ru/company/ruvds/blog/327530/ Bash-скрипты, часть 7: sed и обработка текстов] 
[http://rus-linux.net/MyLDP/consol/sed.html Изучаем команды Linux: sed]

Max Open Files

2017-10-18T07:45:13Z

Vaal: Добавлена страница "Max Open Files"

:В процессе настройки ОС RHEL(5.x-7.x)/CentOS(5.x-7.x) необходимо осуществить обязательную настройку дескрипторов на каждой системе: 
''Все действия'' необходимо производить под правами суперпользователя root(или используя утилиту '''''sudo'''''). Изменить файл ''limits.conf'' находящийся по пути ''/etc/security/'' с добавлением ниже описанных строк в ''начале файла'': 

'''''* soft stack 2048''''' 
'''''* hard stack 2048''''' 
'''''* soft nproc 65536''''' 
'''''* hard nproc 65536''''' 
'''''* soft nofile 1024000''''' 
'''''* hard nofile 1024000''''' 

При этом необходимо сохранить закомментированные строки.
* Изменить файл ''20-nproc.conf''(RHEL 7.x/CentOS 7.x) в директории ''/etc/security/limits.d'' закомментировав в нём строку таким образом: 
'''''# * soft nproc 4096''''' 
* Изменить файл ''90-nproc.conf''(RHEL 5.x-6.x/CentOS 5.x-6.x) в директории ''/etc/security/limits.d'' закомментировав в нём строку таким образом: 
'''''# * soft nproc 1024''''' 

Для вступления параметров в силу необходимо перезагрузить ОС. Проверка вступления параметров в силу осуществляется с помощью следующих команд: 
'''''# ulimit –n''''' — ''Максимальное количество открытых файлов''. Значение 1024000 
'''''# ulimit –s''''' — ''Размер стека''. Значение 2048 
'''''# ulimit –u''''' — ''Максимальное число процессов''. Значение 65536 

Ссылки: 

[http://linux-notes.org/uvelichit-max-open-file-limit-v-linux/ Увеличение Max Open Files Limit в Unix/Linux] 
[https://www.tecmint.com/increase-set-open-file-limits-in-linux/ Increase Open Files Limit]

Установка ZooKeeper на ОС CentOS 7.3

2017-07-28T11:33:53Z

Vaal:

== Введение ==
На данной странице приводится инструкция по установке прикладного ПО ''Zookeeper'' на ОС RHEL и CentOS веток 5.x-6.x, 7.x. 
'''''ZooKeeper''''' — распределённый сервис конфигурирования и синхронизации, не знаю как вам, но мне данное определение мало что раскрывает. Оглядываясь на свой опыт, могу дать альтернативное определение '''''ZooKeeper''''', это распределенное ''key''/''value''(''ключ''/''значение'') хранилище со следующими свойствами:
* ''пространство ключей образует дерево (иерархию подобную файловой системе)'';
* ''значения могут содержаться в любом узле иерархии, а не только в листьях (как если бы файлы одновременно были бы и каталогами), узел иерархии называется znode'';
* ''между клиентом и сервером двунаправленная связь, следовательно, клиент может подписываться как изменение конкретного значения или части иерархии'';
* ''возможно создать временную пару ключ/значение, которая существует, пока клиент, её создавший, подключен к кластеру'';
* ''все данные должны помещаться в память'';
* ''устойчивость к смерти некритического кол-ва узлов кластера(наличие кворума)''.

== Установка ПО Zookeeper на RHEL/CentOS 6.x ==
Для инсталляции будет использоваться [http://apache-mirror.rbc.ru/pub/apache/zookeeper/zookeeper-3.4.6/zookeeper-3.4.6.tar.gz zookeeper версии 3.4.6].
В файл ''~/.bash_profile'', пользователя из-под которого планируется запуск сервисов, должны быть внесены переменные окружения ''JAVA''/''JRUBY'':
<source lang="bash">
# .bash_profile

# Get the aliases and functions
if [ -f ~/.bashrc ]; then
. ~/.bashrc
fi

# User specific environment and startup programs

PATH=/opt/java/bin:$PATH:$HOME/bin:/opt/jruby/bin
JRUBY_HOME=/opt/jruby
PATH=$PATH:$HOME/bin

export PATH
export JRUBY_HOME
</source>

В данном примере настройка ПО ''ZooKeeper'' выполняется под суперпользователем root. 
В данной главе рассматривается вариант установки ПО ''ZooKeeper'' на 6 хостах('''официальная документация рекомендует использовать нечётное кол-во хостов — 3, 5, 7 и т.д.'''). При этом, в данном случае, для работы ПО ''ZooKeeper'' необходимо обеспечить постоянную работу любых четырёх узлов ПО ''ZooKeeper'' из шести. 
Для установки ПО ''ZooKeeper'' на серверах, необходимо выполнить следующие команды на сервере: 
::::1)'''# wget <nowiki>http://apache-mirror.rbc.ru/pub/apache/zookeeper/zookeeper-3.4.6/zookeeper-3.4.6.tar.gz</nowiki> -O /opt/zookeeper.tar.gz''' 
::::::::::::::::::::::или
::::   '''# wget <nowiki>http://apache-mirror.rbc.ru/pub/apache/zookeeper/zookeeper-3.4.6/zookeeper-3.4.6.tar.gz</nowiki> -O /opt/zookeeper.tar.gz'''
::::2)'''# cd /opt; tar zxvf zookeeper.tar.gz && mv zookeeper-3.4.6 zookeeper; chmod +x -R zookeeper/ && mkdir -p /opt/zookeeper/{data,log}'''    '''# sed -i "s|#!/usr/bin/env bash|#!/usr/bin/env bash \n . ~/.bash_profile|" /opt/zookeeper/bin/zkEnv.sh'''    '''# sed -i "s|ZOO_LOG_DIR=\x22\x2E\x22|ZOO_LOG_DIR=\x22/opt/zookeeper/log\x22|" /opt/zookeeper/bin/zkEnv.sh'''    '''# sed -i "s|ZOO_LOG4J_PROP=\x22INFO,CONSOLE\x22|ZOO_LOG4J_PROP=\x22INFO,ROLLINGFILE\x22|" /opt/zookeeper/bin/zkEnv.sh'''
::::3)'''# cat >>/opt/zookeeper/conf/zoo.cfg<<EOF'''
::::'''# Конфигурационный файл ZooKeeper'''
::::'''# Порт для подключения клиентов'''
::::'''clientPort=3000'''
::::'''# Путь к директории с данными ZooKeeper'''
::::'''dataDir=/opt/zookeeper/data'''
::::'''# Длина такта (в миллисекундах)'''
::::'''tickTime=2000'''
::::'''# Количество тактов для подключения к лидеру и синхронизации с ним'''
::::'''initLimit=10'''
::::'''# Количество тактов для синхронизации с лидером'''
::::'''syncLimit=5'''
::::'''# Периодичность удаления старых данных ZooKeeper (в часах). 0 - не удалять.'''
::::'''autopurge.purgeInterval=1'''
::::'''# Количество файлов, оставляемое при удалении старых данных'''
::::'''autopurge.snapRetainCount=3'''
::::'''# Адреса всех серверов кластера ZooKeeper'''
::::'''# Формат: server.number=host:leader_port:election_port[:observer]'''
::::'''server.1=ip_addr_1:3001:3002'''
::::'''server.2=ip_addr_2:3001:3002'''
::::'''server.3=ip_addr_3:3001:3002'''
::::'''server.4=ip_addr_4:3001:3002'''
::::'''server.5=ip_addr_5:3001:3002'''
::::'''server.6=ip_addr_6:3001:3002'''
::::'''EOF'''
::::4)'''# chown user_dev:user_dev -R /opt/zookeeper/ && scp -Cqr /opt/zookeeper/ root@ip_addr_2:/opt/;''' &ensp; '''# scp -Cqr /opt/zookeeper/ root@ip_addr_3:/opt/'''    '''# scp -Cqr /opt/zookeeper/ root@ip_addr_4:/opt/'''    '''# scp -Cqr /opt/zookeeper/ root@ip_addr_5:/opt/'''    '''# scp -Cqr /opt/zookeeper/ root@ip_addr_6:/opt/'''
::::5)'''# echo '1' > /opt/zookeeper/data/myid;'''    '''# ssh root@ip_addr_2 "echo 2 > /opt/zookeeper/data/myid && chown user_dev. /opt/zookeeper/data/myid;"'''    '''# ssh root@ip_addr_3 "echo 3 > /opt/zookeeper/data/myid && chown user_dev. /opt/zookeeper/data/myid;"'''    '''# ssh root@ip_addr_4 "echo 4 > /opt/zookeeper/data/myid && chown user_dev. /opt/zookeeper/data/myid;"'''    '''# ssh root@ip_addr_5 "echo 5 > /opt/zookeeper/data/myid && chown user_dev. /opt/zookeeper/data/myid;"'''    '''# ssh root@ip_addr_6 "echo 6 > /opt/zookeeper/data/myid && chown user_dev. /opt/zookeeper/data/myid;"'''
::::6)'''# chmod +x /opt/zookeeper/check_zoo.sh; sleep 0.2; echo '*/1 * * * * /opt/zookeeper/check_zoo.sh' >> /var/spool/cron/root'''    '''# ssh root@ip_addr_2 "chmod +x /opt/zookeeper/check_zoo.sh; sleep 0.2; echo '*/1 * * * * /opt/zookeeper/check_zoo.sh' >> /var/spool/cron/root"'''    '''# ssh root@ip_addr_3 "chmod +x /opt/zookeeper/check_zoo.sh; sleep 0.2; echo '*/1 * * * * /opt/zookeeper/check_zoo.sh' >> /var/spool/cron/root"'''    '''# ssh root@ip_addr_4 "chmod +x /opt/zookeeper/check_zoo.sh; sleep 0.2; echo '*/1 * * * * /opt/zookeeper/check_zoo.sh' >> /var/spool/cron/root"'''    '''# ssh root@ip_addr_5 "chmod +x /opt/zookeeper/check_zoo.sh; sleep 0.2; echo '*/1 * * * * /opt/zookeeper/check_zoo.sh' >> /var/spool/cron/root"'''    '''# ssh root@ip_addr_6 "chmod +x /opt/zookeeper/check_zoo.sh; sleep 0.2; echo '*/1 * * * * /opt/zookeeper/check_zoo.sh' >> /var/spool/cron/root"'''

== Установка ПО Zookeeper на RHEL/CentOS 7.x ==
Для инсталляции будет использоваться [http://apache-mirror.rbc.ru/pub/apache/zookeeper/zookeeper-3.4.10/zookeeper-3.4.10.tar.gz zookeeper версии 3.4.10].
В файл ~/.bash_profile, пользователя из-под которого планируется запуск сервисов, должны быть внесены переменные окружения JAVA/JRUBY:
# .bash_profile
# Get the aliases and functions
if [ -f ~/.bashrc ]; then
. ~/.bashrc
fi 
# User specific environment and startup programs
PATH=/opt/java/bin:$PATH:$HOME/bin:/opt/jruby/bin
JRUBY_HOME=/opt/jruby
PATH=$PATH:$HOME/bin 
export PATH
export JRUBY_HOME

Все действия выполняются под пользователем root(сервер 10.160.20.186, владельцем директорий будет пользователь ''user_dev'', запуск сервиса будет осуществляться из-под пользователя ''user_dev''):
* '''Переходим в каталог /opt и скачиваем актуальную версию ПО Zookeeper(в нашем случае — 3.4.10) с официального сайта'''
'''# cd /opt && wget <nowiki>http://apache-mirror.rbc.ru/pub/apache/zookeeper/zookeeper-3.4.10/zookeeper-3.4.10.tar.gz</nowiki>'''
* '''Распаковываем скачанный архив, переименовываем директорию, назначаем владельцем пользователя ''user_dev'' '''
'''# tar xzvf zookeeper-3.4.10.tar.gz && mv zookeeper-3.4.10 zookeeper && chown user_dev. -R /opt/zookeeper'''
* '''Настраиваем инстанс ''zookeeper'' на сервере''':
'''a)''' Добавляем в файл zkEnv.sh строку ". ~/.bash_profile" сразу после строки "#!/usr/bin/env bash" (для упрощения приводится команда [[sed]]):
# sed -i "s|#!/usr/bin/env bash|#!/usr/bin/env bash \n . ~/.bash_profile|" /opt/zookeeper/bin/zkEnv.sh 
'''b)''' Изменяем параметр ZOO_LOG_DIR в файле zkEnv.sh(для упрощения приводится команда sed):
# sed -i "s|ZOO_LOG_DIR=\x22\x2E\x22|ZOO_LOG_DIR=\x22/opt/zookeeper/log\x22|" /opt/zookeeper/bin/zkEnv.sh 
'''c)''' Изменяем параметр ZOO_LOG4J_PROP в файле zkEnv.sh(для упрощения приводится команда [[sed]]):
# sed -i "s|ZOO_LOG4J_PROP=\x22INFO,CONSOLE\x22|ZOO_LOG4J_PROP=\x22INFO,ROLLINGFILE\x22|" /opt/zookeeper/bin/zkEnv.sh 
'''d)''' Создаём директории data и log:
# mkdir -p /opt/zookeeper/{data,log} 
'''e)''' Создаём файл myid в директории data и в него помещаем значение 1:
# echo '1' > /opt/zookeeper/data/myid 
'''f)''' Настраиваем файл /opt/zookeeper/conf/zoo.cfg, далее приведена настройка для сервера 10.160.22.186:
# echo > /opt/zookeeper/conf/zoo.cfg
# cat >>/opt/zookeeper/conf/zoo.cfg <<EOF
# ZooKeeper node2 
#.... 
clientPort=3010 
# ZooKeeper 
dataDir=/opt/zookeeper/data 
# ( ) 
tickTime=2000 
#.......... 
initLimit=20 
#...... 
syncLimit=10 
# ZooKeeper ( ). 0 - . 
autopurge.purgeInterval=1 
# ,..... 
autopurge.snapRetainCount=3 
# ZooKeeper 
# : server.number=host:leader_port:election_port[:observer] 
server.1=10.160.22.186:3001:3002 
server.2=10.160.22.186:3003:3004 
server.3=10.160.22.188:3005:3006 
server.4=10.160.22.188:3007:3008 
EOF 
'''g)''' Создаём файл сервиса ZooKeeper:
# touch /etc/systemd/system/ZooKeeper.service 
'''h)''' Редактируем созданный на этапе '''g''') файл:
# cat >> /etc/systemd/system/ZooKeeper.service <<EOF
[Unit]
Description=Apache Zookeeper server.
<nowiki>Documentation=http://zookeeper.apache.org</nowiki>
Requires=network.target remote-fs.target.
After=network.target remote-fs.target
 
[Service]
Type=forking
User=user_dev
Group=user_dev
ExecStart=/opt/zookeeper/bin/zkServer.sh start
ExecStop=/opt/zookeeper/bin/zkServer.sh stop
ExecReload=/opt/zookeeper/bin/zkServer.sh restart
Restart=always
 
[Install]
WantedBy=multi-user.target
EOF
 
* '''Назначаем владельцем директорий /opt/zookeeper пользователя user_dev:'''
'''#chown user_dev. -R /opt/zookeeper''' 
* '''Добавляем сервис ZooKeeper.service в автозагрузку:'''
'''# systemctl enable ZooKeeper.service 
* '''Запускаем сервисы:'''
'''#systemctl daemon-reload && systemctl start ZooKeeper.service 
* '''Проверяем статусы сервиса:'''
'''#systemctl status ZooKeeper.service 

* ZooKeeper.service - Apache Zookeeper server
Loaded: loaded (/etc/systemd/system/ZooKeeper.service; enabled; vendor preset: disabled)
Active: active (running) since Пт 2017-07-28 08:44:33 MSK; 1h 2min ago
Docs: <nowiki>http://zookeeper.apache.org</nowiki>
Process: 2275 ExecStart=/opt/zookeeper/bin/zkServer.sh start (code=exited, status=0/SUCCESS)
Main PID: 2290 (java)
CGroup: /system.slice/ZooKeeper.service
L-2290 java -Dzookeeper.log.dir=/opt/zookeeper/log -Dzookeeper.root.logger=INFO,ROLLINGFILE -cp /o
pt/zookeeper/bin/../build/classes:/opt/zookeeper/bin/../build/lib/*.jar:/op...
июл 28 08:44:32 VM-V-App-03 systemd[1]: Starting Apache Zookeeper server...
июл 28 08:44:32 VM-V-App-03 zkServer.sh[2275]: ZooKeeper JMX enabled by default
июл 28 08:44:32 VM-V-App-03 zkServer.sh[2275]: Using config: /opt/zookeeper/bin/../conf/zoo.cfg
июл 28 08:44:33 VM-V-App-03 systemd[1]: Started Apache Zookeeper server.

* '''Перезагружаем сервер, после чего проверяем загрузились ли сервисы ZooKeeper'''
 

== P.S. ==
'''''Для проверки получения ответа с сервера 10.160.22.186 выполним команды на сервере 10.160.22.188(должен быть инсталлирован netcat):''''' 
'''# echo "ruok" | nc 10.160.22.186 3010 ; echo ''' 
'''# echo "ruok" | nc 10.160.22.186 3020 ; echo ''' 

== Ссылки ==
[http://zookeeper.apache.org Apache Zookeeper Home] 
[http://apache-mirror.rbc.ru/pub/apache/zookeeper/zookeeper-3.4.10/zookeeper-3.4.10.tar.gz Пакет ПО Zookeeper версии 3.4.10] 
[https://habrahabr.ru/post/144708/ ZooKeeper или пишем сервис распределенных блокировок ] 
[http://10.160.22.182:9009/scripts/Var_Scripts/blob/master/zk_inst_kbsh_tk2.sh Скрипт первоначальной установки ZooKeeper] 
[http://10.160.22.182:9009/scripts/Var_Scripts/tree/master Репозиторий со скриптами автоматизации установки ZooKeeper]

Advanced Bash-Scripting Guide

2017-06-22T09:28:17Z

Vaal:

'''bash''' (от англ. '''B'''ourne '''a'''gain '''sh'''ell, каламбур «Born again» shell — «возрождённый» shell) — усовершенствованная и модернизированная вариация командной оболочки Bourne shell. Одна из наиболее популярных современных разновидностей командной оболочки UNIX. Особенно популярна в среде Linux, где она часто используется в качестве предустановленной командной оболочки. 
[[File:Bash_highway_to_shell.jpg|center|250px]]
Bash — это командный процессор, работающий, как правило, в интерактивном режиме в текстовом окне. Bash также может читать команды из файла, который называется скриптом (или сценарием). Как и все Unix-оболочки, он поддерживает автодополнение имён файлов и директорий, подстановку вывода результата команд, переменные, контроль за порядком выполнения, операторы ветвления и цикла. Ключевые слова, синтаксис и другие основные особенности языка были заимствованы из sh. Другие функции, например, история, были скопированы из csh и ksh. Bash в основном удовлетворяет стандарту POSIX, но с рядом расширений.

Название «bash» является акронимом от Bourne-again-shell («ещё-одна-командная-оболочка-Борна») и представляет собой игру слов: Bourne-shell — одна из популярных разновидностей командной оболочки для UNIX (sh), автором которой является Стивен Борн (1978), усовершенствована в 1987 году Брайаном Фоксом. Фамилия Bourne (Борн) перекликается с английским словом born, означающим «родившийся», отсюда: рождённая-вновь-командная оболочка.

В сентябре 2014 года в bash была обнаружена широко эксплуатируемая уязвимость Bashdoor.

Данный документ является копией электронной версии [[:File:Advanced-Bash-Scripting-Guide.pdf|Advanced-Bash-Scripting-Guide]]
= Часть первая. Введение =
'''Shell''' — это командная оболочка. Но это не просто промежуточное звено между пользователем и операционной системой, это ещё и мощный язык программирования. Программы на языке shell называют сценариями, или скриптами. Фактически, из скриптов доступен полный набор команд, утилит и программ Unix. Если этого недостаточно, то к вашим услугам внутренние команды shell — условные операторы, операторы циклов и пр., которые увеличивают мощь и гибкость сценариев. Shell-скрипты исключительно хороши при программировании задач администрирования системы и др., которые не требуют для своего создания полновесных языков программирования.
== Зачем необходимо знание языка Shell? ==
 Знание языка командной оболочки является залогом успешного решения задач администрирования системы. Даже если вы не предполагаете заниматься написанием своих сценариев. Во время загрузки Linux выполняется целый ряд сценариев из /etc/rc.d, которые настраивают конфигурацию операционной системы и запускают различные сервисы, поэтому очень важно четко понимать эти скрипты и иметь достаточно знаний, чтобы вносить в них какие либо изменения. Язык сценариев легок в изучении, в нем не так много специфических операторов и конструкций.
 
 Синтаксис языка достаточно прост и прямолинеен, он очень напоминает команды, которые приходится вводить в командной строке. Короткие скрипты практически не нуждаются в отладке, и даже отладка больших скриптов отнимает весьма незначительное время.
Shell-скрипты очень хорошо подходят для быстрого создания прототипов сложных приложений, даже не смотря на ограниченный набор языковых конструкций и определенную "медлительность". Такой метод позволяет детально проработать структуру будущего приложения, обнаружить возможные"ловушки" и лишь затем приступить к кодированию на C, C++, Java, или Perl.
 
 Скрипты возвращают нас к классической философии Unix — "разделяй и властвуй" т.е. разделение сложного проекта на ряд простых подзадач. Многие считают такой подход наилучшим или, по меньшей мере, наиболее эстетичным способом решения возникающих проблем, нежели использование нового поколения языков — "всё-в-одном", таких как Perl. 
'''''Для каких задач неприменимы скрипты''''':
* для ресурсоемких задач, особенно когда важна скорость исполнения (поиск, сортировка и т.п.)
* для задач, связанных с выполнением математических вычислений, особенно это касается вычислений с плавающей запятой, вычислений с повышенной точностью, комплексных чисел(для таких задач лучше использовать C++ или FORTRAN)
* для кросс-платформенного программирования (для этого лучше подходит язык C)
* для сложных приложений, когда структурирование является жизненной необходимостью(контроль за типами переменных, прототипами функций и т.п.)
* для целевых задач, от которых может зависеть успех предприятия
* когда во главу угла поставлена безопасность системы, когда необходимо обеспечить целостность системы и защитить её от вторжения, взлома и вандализма
* для проектов, содержащих компоненты, очень тесно взаимодействующие между собой
* для задач, выполняющих огромный объем работ с файлами
* для задач, работающих с многомерными массивами
* когда необходимо работать со структурами данных, такими как связанные списки или деревья
* когда необходимо предоставить графический интерфейс с пользователем (GUI)
* когда необходим прямой доступ к аппаратуре компьютера
* когда необходимо выполнять обмен через порты ввода-вывода или сокеты
* когда необходимо использовать внешние библиотеки
* для проприетарных, "закрытых" программ (скрипты представляют из себя исходные тексты программ, доступные для всеобщего обозрения)
 
Если выполняется хотя бы одно из вышеперечисленных условий, то вам лучше обратиться к более мощным скриптовым языкам программирования, например '''Perl''', '''Tcl''', '''Python''', '''Ruby''' или к высокоуровневым компилирующим языкам — '''C''', '''C++''' или '''Java'''. Но даже в этом случае, создание прототипа приложения на языке '''shell''' может существенно облегчить разработку.
Название BASH — это аббревиатура от "Bourne-Again Shell" и игра слов от, ставшего уже классикой,"Bourne Shell" Стефена Бурна (Stephen Bourne). В последние годы BASH достиг такой популярности,что стал стандартной командной оболочкой de facto для многих разновидностей Unix. Большинство принципов программирования на BASH одинаково хорошо применимы и в других командных оболочках, таких как Korn Shell (ksh), от которой Bash позаимствовал некоторые особенности,
и CShell и его производных(Примечательно, что C Shell не рекомендуется к использованию из-за отдельных проблем, отмеченных Томом Кристиансеном (Tom Christiansen) в октябре 1993 года на Usenet post).
 
 Далее, в тексте документа вы найдете большое количество примеров скриптов, иллюстрирующихвозможности shell. Все примеры -- работающие. Они были протестированы, причем некоторые из них могут пригодиться в повседневной работе. Уважаемый читатель может "поиграть" с рабочим кодом скриптов, сохраняя их в файлы, с именами scriptname.sh.
 
 Не забудьте выдать этим файлам право на исполнение (chmod u+rx scriptname.sh), после чего сценарии можно будет запустить на исполнение и проверить результат их работы. Вам следует помнить, что описание некоторых примеров следует после исходного кода этого примера, поэтому, прежде чем запустить сценарий у себя — ознакомьтесь с его описанием. Скрипты были написаны автором книги, если не оговаривается иное.

== Для начала о Sha-Bang ==
 В простейшем случае, скрипт — это ни что иное, как простой список команд системы, записанный в файл. Создание скриптов поможет сохранить ваше время и силы, которые тратятся на ввод последовательности команд всякий раз, когда необходимо их выполнить.
 '''Пример. cleanup''': '''''Сценарий очистки лог-файлов в /var/log'''''
<source lang="bash">
# cleanup
# Для работы сценария требуются права root.
cd /var/log
cat /dev/null > messages
cat /dev/null > wtmp
echo "Лог-файлы очищены."
</source>

 '''Пример. cleanup''': '''''Расширенная версия предыдущего сценария.'''''
<source lang="bash">
#!/bin/bash
# cleanup, version 2
# Для работы сценария требуются права root.
LOG_DIR=/var/log
ROOT_UID=0 # Только пользователь с $UID 0 имеет привилегии root.
LINES=50 # Количество сохраняемых строк по-умолчанию.
E_XCD=66 # Невозможно сменить каталог?
E_NOTROOT=67 # Признак отсутствия root-привилегий.

if [ "$UID" -ne "$ROOT_UID" ]; then
echo "Для работы сценария требуются права root."
exit $E_NOTROOT
fi

if [ -n "$1" ]; then
# Проверка наличия аргумента командной строки
lines=$1
else lines=$LINES # Значение по-умолчанию, если число не задано в командной строке
fi

# Stephane Chazelas предложил следующее,
#+ для проверки корректности аргумента, переданного из командной строки,
#+ правда это достаточно сложно для данного руководства.
#
# E_WRONGARGS=65 # Не числовой аргумент
#
# case "$1" in
# "" ) lines=50;;
# *[!0-9]*) echo "Usage: `basename $0` file-to-cleanup"; exit $E_WRONGARGS;;
# * ) lines=$1;;
# esac
#
#* Конец проверки корректности аргумента

cd $LOG_DIR
if [ `pwd` != "$LOG_DIR" ]; then
# или if [ "$PWD" != "$LOG_DIR" ]
# не в /var/log?
echo "Невозможно перейти в каталог $LOG_DIR."
exit $E_XCD
fi # Проверка каталога перед очисткой лог-файлов.
# более эффективный вариант:
#
# cd /var/log || {
# echo "Невозможно перейти в требуемый каталог." >&2# exit $E_XCD;
# }

tail -$lines messages > mesg.temp # Сохранить последние строки в лог-файле.
mv mesg.temp messages
# cat /dev/null > messages
#* Необходимость этой команды отпала, поскольку очистка выполняется выше.
cat /dev/null > wtmp # команды ': > wtmp' и '> wtmp' имеют тот же эффект.
echo "Лог-файлы очищены."
exit 0 # Возвращаемое значение 0
#+ указывает на успешное завершение работы сценария.
</source>
 
Если вы не желаете полностью вычищать системные логи, то выше представлена улучшенная версия предыдущего сценария. Здесь сохраняются последние несколько строк (по-умолчанию — 50).
Если файл сценария начинается с последовательности #!, которая в мире Unix называется '''''sha-bang''''', то это указывает системе какой интерпретатор следует использовать для исполнения сценария. Это двухбайтовая последовательность, или — специальный маркер, определяющий тип сценария, в данном случае — сценарий командной оболочки (см. man magic). Более точно, '''''sha-bang''''' определяет интерпретатор, который вызывается для исполнения сценария, это может быть командная оболочка(shell), иной интерпретатор или утилита:
#!/bin/bash
#!/usr/bin/perl
#!/usr/bin/tcl
#!/bin/sed -f
#!/usr/awk -f
 
Каждая, из приведенных выше сигнатур, приводит к вызову различных интерпретаторов, будь то /bin/sh — командный интерпретатор по-умолчанию (bash для Linux-систем), либо иной. При переносе сценариев с сигнатурой '''''#!/bin/sh''''' на другие Unix системы, где в качестве командного интерпретатора задан другой shell, вы можете лишиться некоторых особенностей, присущих bash. Поэтому такие сценарии должны быть POSIX совместимыми.
 
Обратите внимание на то, что сигнатура должна указывать правильный путь к интерпретатору, впротивном случае вы получите сообщение об ошибке -- как правило это "Command not found".
Сигнатура '''''#!''''' может быть опущена, если вы не используете специфичных команд. Во втором примере(см. выше) использование сигнатуры #! обязательно, поскольку сценарий использует специфичную конструкцию присваивания значения переменной '''lines=50'''. Ещё раз замечу, что сигнатура '''''#!/bin/sh''''' вызывает командный интерпретатор по-умолчанию — /bin/bash в Linux-системах.
 
В данном руководстве приветствуется модульный подход к построению сценариев. Записывайте, собирайте свою коллекцию участков кода, который может вам встретиться. В конечном итоге вы соберете свою "библиотеку" подпрограмм, которые затем сможете использовать при написании своих сценариев. Например, следующий отрывок сценария проверяет количество аргументов в командной строке:
<source lang="bash">
if [ $# -ne Number_of_expected_args ]; then
echo "Usage: `basename $0` whatever"
exit $WRONG_ARGS
fi
</source>
=== Запуск сценария ===
Запустить сценарий можно командой '''''sh scriptname''''' или '''''bash scriptname'''''. (Не рекомендуется запуск сценария командой '''sh < scriptname''', поскольку это запрещает использование устройства стандартного ввода '''stdin''' в скрипте). Более удобный вариант — сделать файл скрипта исполняемым, командой [[chmod]].
 Это:
<source lang="bash">chmod 555 scriptname (выдача прав на чтение/исполнение любому пользователю в системе)</source>
или
 
<source lang="bash">chmod +rx scriptname (выдача прав на чтение/исполнение любому пользователю в системе)</source>
<source lang="bash">chmod u+rx scriptname (выдача прав на чтение/исполнение только "владельцу" скрипта)</source>
 
После того, как вы сделаете файл сценария исполняемым, вы можете запустить его примерно такой командой ./scriptname.
Если, при этом, текст сценария начинается с корректной сигнатуры ('''''"sha-bang"'''''), то для его исполнения будет вызван соответствующий интерпретатор.
 
И наконец, завершив отладку сценария, вы можете поместить его в каталог '''''/usr/local/bin'''''(естественно, что для этого вы должны обладать правами root), чтобы сделать его доступным для себя и других пользователей системы. После этого сценарий можно вызвать, просто напечатав название файла в командной строке и нажав клавишу '''[ENTER]'''.
=== Упражнения ===
1) Системные администраторы часто создают скрипты для автоматизации своего труда. Подумайте, для выполнения каких задач могут быть написаны сценарии.
 
2) Напишите сценарий, который выводит '''''дату''''', '''''время''''', '''''список зарегистрировавшихся пользователей''''', и '''''uptime системы''''' и сохраняет эту информацию в системном журнале.

= Часть вторая. Основы =
== Служебные символы ==
Служебные символы, используемые в текстах сценариев:
 
* <big>'''''#'''''</big> — Комментарии.
 Строки, начинающиеся с символа # (за исключением комбинации #!) являются комментариями.
<source lang="bash">
# Эта строка — комментарий.
</source>
Комментарии могут располагаться и в конце строки с исполняемым кодом.
 
<source lang="bash">
echo "Далее следует комментарий." # Это комментарий.
</source>
Комментариям могут предшествовать пробелы (пробел, табуляция).
 
<source lang="bash">
# Перед комментарием стоит символ табуляции.
</source>
Исполняемые команды не могут следовать за комментарием в той же самой строке. Пока что еще не существует способа отделения комментария от "исполняемого кода", следующего за комментарием в той же строке.
 
Само собой разумеется, экранированный символ '''''#''''' в операторе [[echo]] не воспринимается как начало комментария. Более того, он может использоваться в операциях подстановки параметров и в константных числовых выражениях.
echo "Символ # не означает начало комментария."
echo 'Символ # не означает начало комментария.'
echo Символ \# не означает начало комментария.
echo А здесь символ # ''означает начало комментария.''
echo ${PATH#*:} # Подстановка — не комментарий.
echo $(( 2#101011 )) # База системы счисления — не комментарий.

Двойные кавычки('''''"'''''), одинарная кавычка(<nowiki>'</nowiki>) и символ обратного "слеша"('''''\''''') экранируют действие символа '''''#'''''.
В операциях поиска по шаблону символ '''''#''''' так же не воспринимается как начало комментария.
 
* <big>''''';'''''</big> — Разделитель команд. '''''[Точка-с-запятой]'''''
Позволяет записывать две и более команд в одной строке.
<source lang="bash">
echo hello; echo there
if [ -x "$filename" ]; then # Обратите внимание: "if" И "then" разделены точкой с запятой.
# Почему?
echo "Файл $filename найден."; cp $filename $filename.bak
else echo "Файл $filename не найден."; touch $filename
fi;
echo "Конец."
</source>
Следует отметить, что символ <big>''''';'''''</big> иногда так же как и <big>'''''#'''''</big> необходимо экранировать.
 
* <big>''''';;'''''</big> — Ограничитель в операторе выбора case. '''''[Двойная-точка-с-запятой]'''''
<source lang="bash">
case "$variable"
in
abc) echo "$variable = abc" ;;
xyz) echo "$variable = xyz" ;;
esac
</source>
* <big>'''''.'''''</big> — Команда "точка"('''''.''''')
Эквивалент команды '''''source'''''. Это встроенная команда '''''bash'''''. "точка" может являться частью имени файла. Если имя файла начинается с точки, то это "скрытый" файл, т.е. команда [[Ls_—_Команда_печати_содержимого_каталога|ls]] при обычных условиях его не отображает:
[[File:Ls hidden.PNG|center|650px]]
 Если подразумевается имя каталога, то одна точка означает текущий каталог и две точки — каталог уровнем выше или родительский каталог:
[[File:Parent dir.PNG|center|400px]]
Символ <big>'''''.'''''</big> ("точка") довольно часто используется для обозначения каталога назначения в операциях копирования/перемещения файлов.
<source lang="bash">
bash$ cp /home/bozo/current_work/junk/* .
</source>
Символ <big>'''''.'''''</big> ("точка") в операциях поиска. При выполнении поиска по шаблону, в регулярных выражениях, символ <big>'''''.'''''</big> ("точка") обозначает одиночный символ.
* <big>'''''"'''''</big> — Двойные кавычки('''''"''''')
В строке "STRING", ограниченной двойными кавычками не выполняется интерпретация большинства служебных символов, которые могут находиться в строке.
* <big>'</big> — Одинарные кавычки(')
Одинарные кавычки 'STRING' экранируют все служебные символы в строке STRING. Это более строгая форма экранирования.
* <big>''''','''''</big> — Запятая(''''',''''')
Оператор запятая(<big>''''','''''</big>) используется для вычисления серии арифметических выражений. Вычисляются все выражения, но возвращается результат последнего выражения.
<source lang="bash">
let "t2 = ((a = 9, 15 / 3))" # Присваивает значение переменной "a" и вычисляет "t2".
</source>
* <big>'''''\'''''</big> — Обратный слэш('''''\''''')
Комбинация \X "экранирует" символ X. Аналогичный эффект имеет комбинация с "одинарными кавычками", т.е. 'X'. Символ \ может использоваться для экранирования кавычек " и '.
* <big>'''''/'''''</big> — Слэш('''''/''''')
Разделитель, используемый в указании пути к каталогам и файлам. Слэш отделяет элементы пути к каталогам и файлам (например, /home/bozo/projects/Makefile).
В арифметических операциях — это оператор деления.
* <big>'''''`'''''</big> — Обратная кавычка('''''`''''')
С помощью символа обратной кавычки(<big>'''''`'''''</big>) осуществляется подстановка команд. Обратные кавычки могут использоваться для записи в переменную команды '''''`command`'''''.
* <big>''''':'''''</big> — Двоеточие(''''':''''')
Пустая команда. Это эквивалент операции "NOP" (no op, нет операции). Может рассматриваться как синоним встроенной команды true. Команда ":" так же является встроенной командой Bash, которая всегда возвращает "true" (0).
<source lang="bash">
:
echo $? # 0
</source>
Бесконечный цикл:
<source lang="bash">
while :
do
operation-1
operation-2
...
operation-n
done
# То же самое:
# while true
# do
# ...
# done
</source>
Символ-заполнитель в условном операторе if/then:
<source lang="bash">
if condition
then : # Никаких действий не производится и управление передаётся дальше
else
take-some-action
fi
</source>
Как символ-заполнитель в операциях, которые предполагают наличие двух операндов:
<source lang="bash">
: ${username=`whoami`}
# ${username=`whoami`} без символа : выдает сообщение об ошибке,
# если "username" не является командой...
</source>
Как символ-заполнитель для оператора вложенного документа.
В операциях с подстановкой параметров:
<source lang="bash">
: ${HOSTNAME?} ${USER?} ${MAIL?}
#Вывод сообщения об ошибке, если одна или более переменных не определены.
</source>
В операциях замены подстроки с подстановкой значений переменных.
В комбинации с оператором > (оператор перенаправления вывода), усекает длину файла до нуля. Если указан несуществующий файл — то он создаётся.
<source lang="bash">
: > data.xxx # Файл "data.xxx" — пуст
# Тот же эффект имеет команда cat /dev/null >data.xxx
# Однако в данном случае не производится создание нового процесса, поскольку ":" является встроенной командой.
</source>
В комбинации с оператором '''''>>''''' — если задано имя существующего файла, то эта комбинация на него никак не влияет (''''': >> target_file'''''). Если задано имя несуществующего файла, то он создаётся.
Вышеизложенное применимо только к обычным файлам и неприменимо к конвейерам, символическим ссылкам и другим специальным файлам. Символ <big>:</big> может использоваться для создания комментариев, хотя и не рекомендуется. Если строка комментария начинается с символа <big>'''''#'''''</big>, то такая строка не проверяется интерпретатором на наличие ошибок. Однако в случае оператора <big>''''':'''''</big> это не так.
<source lang="bash">
: Это комментарий, который генерирует сообщение об ошибке, ( if [ $x -eq 3] ).
</source>
Символ <big>''''':'''''</big> может использоваться как разделитель полей в /etc/passwd и переменной $PATH.
<source lang="bash">
bash$ echo $PATH
/usr/local/bin:/bin:/usr/bin:/usr/X11R6/bin:/sbin:/usr/sbin:/usr/games
</source>
* <big>'''''!'''''</big> — Восклицательный знак('''''!''''')
Инверсия (или логическое отрицание) используемое в условных операторах.
Оператор <big>'''''!'''''</big> инвертирует код завершения команды, к которой он применен. Также используется для логического отрицания в операциях сравнения, например, операция сравнения "равно"(=), при использовании оператора отрицания, преобразуется в операцию сравнения — "не равно" ( != ). Символ <big>'''''!'''''</big> является зарезервированным ключевым словом BASH. В некоторых случаях символ <big>'''''!'''''</big> используется для косвенного обращения к переменным.
Кроме того, из командной строки оператор <big>'''''!'''''</big> запускает механизм историй Bash. Примечательно, что этот механизм недоступен из сценариев(т.е. исключительно из командной строки).
* <big>'''''*'''''</big> — Символ "звёздочка"('''''*''''')
Символ <big>'''''*'''''</big> ("звёздочка") служит "шаблоном" для подстановки в имена файлов. Одиночный символ <big>'''''*'''''</big> означает любое имя файла в заданном каталоге.
<source lang="bash">
bash$ echo *
abs-book.sgml add-drive.sh agram.sh alias.sh
</source>
В регулярных выражениях токен <big>'''''*'''''</big> представляет любое количество (в том числе и 0) символов. В арифметических выражениях символ <big>'''''*'''''</big> обозначает операцию умножения. Двойная звёздочка (два символа звёздочки, следующих подряд друг за другом — <big>'''''**'''''</big>),обозначает операцию возведения в степень.
* <big>'''''?'''''</big> — Вопросительный знак('''''?''''')
Оператор проверки условия. В некоторых выражениях символ <big>'''''?'''''</big> служит для проверки выполнения условия. В конструкциях с двойными скобками, символ <big>'''''?'''''</big> подобен трёхместному оператору языка C. В выражениях с подстановкой параметра, символ <big>'''''?'''''</big> проверяет — установлена ли переменная.
Символ <big>'''''?'''''</big> обозначает одиночный символ при подстановке в имена файлов. В регулярных выражениях служит для обозначения одиночного символа.
* <big>'''''$'''''</big> — Символ доллара('''''$''''')
Символ <big>'''''$'''''</big> предшествующий имени переменной, указывает на то, что будет получено значение переменной:
<source lang="bash">
var1=5
var2=23skidoo
echo $var1 # 5
echo $var2 # 23skidoo
</source>
В регулярных выражениях, символ <big>'''''$'''''</big> обозначает конец строки.
<big>'''''${ }'''''</big> — подстановка параметра.
<big>'''''$*'''''</big>,<big>'''''$@'''''</big> — параметры командной строки.
<big>'''''$?'''''</big> — Переменная "$?" хранит код завершения последней выполненной команды, функции или сценария.
<big>'''''$$'''''</big> — Переменная "$$" хранит id процесса сценария.
* <big>'''''( )'''''</big> — Круглые скобки('''''()''''')
Команды, заключённые в круглые скобки (<big>'''''( )'''''</big>) исполняются в дочернем процессе — subshell.
<source lang="bash">
(a=hello; echo $a)
</source>
Переменные, создаваемые в дочернем процессе не видны в "родительском" сценарии. Родительский процесс-сценарий, не может обращаться к переменным, создаваемым в дочернем процессе.
<source lang="bash">
a=123
( a=321; )
echo "a = $a" # a = 123
#Переменная "a" в скобках подобна локальной переменной.
</source>
Круглые скобки (<big>'''''()'''''</big>) также используются для инициализации массивов:
<source lang="bash">
Array=(element1 element2 element3)
</source>
<big>'''''(( ))'''''</big> — двойные круглые скобки.Вычисляется целочисленное выражение, заключенное между двойными круглыми скобками <big>'''''(( ))'''''</big>.
* <big>'''''{}'''''</big> — Фигурные скобки('''''{}''''')
Команда интерпретируется как список команд, разделённых точкой с запятой, с вариациями, представленными в фигурных скобках. При интерпретации имён файлов (подстановка) используются параметры, заключённые в фигурные скобки.
<source lang="bash">
grep Linux file*.{txt,htm*}# Поиск всех вхождений слова "Linux"
# в файлах "fileA.txt", "file2.txt", "fileR.html", "file-87.htm", и пр.
</source>
Использование ''неэкранированных'' или ''неокавыченных'' пробелов внутри фигурных скобок недопустимо!
<source lang="bash">
echo {file1,file2}\ :{\ A," B",' C'}
file1 : A file1 : B file1 : C file2 : A file2 : B file2 : C
</source>
<big>'''''{}'''''</big> — Известен так же как "вложенный блок", эта конструкция, фактически, создаёт анонимную функцию. Однако, в отличии от обычных функций, переменные, создаваемые во вложенных блоках кода, доступны объемлющему сценарию.
<source lang="bash">
bash$ { local a; a=123; }
bash: local: can only be used in a function
</source>
<source lang="bash">
a=123
{ a=321; }
echo "a = $a"
# a = 321 (значение, присвоенное во вложенном блоке кода)
</source>
Код, заключенный в фигурные скобки, может выполнять перенаправление ввода-вывода.

 '''Пример.''': '''''Вложенные блоки и перенаправление ввода-вывода.'''''
<source lang="bash">
#!/bin/bash
# Чтение строк из файла /etc/fstab.
File=/etc/fstab
{read line1
read line2
} < $File
echo "Первая строка в $File :"
echo "$line1"
echo
echo "Вторая строка в $File :"
echo "$line2"
exit 0
</source>
 '''Пример.''': '''''Сохранение результата исполнения вложенного блока в файл'''''
<source lang="bash">
#!/bin/bash
# rpm-check.sh
# Запрашивает описание rpm-архива, список файлов, и проверяется возможность установки.
# Результат сохраняется в файле.
#
# Этот сценарий иллюстрирует порядок работы со вложенными блоками кода.
SUCCESS=0
E_NOARGS=65
if [ -z "$1" ]; then
echo "Порядок использования: `basename $0` rpm-file"
exit $E_NOARGS
fi
{
echo
echo "Описание архива:"
rpm -qpi $1 # Запрос описания.
echo
echo "Список файлов:"
rpm -qpl $1 # Запрос списка.
echo
rpm -i --test $1 # Проверка возможности установки.
if [ "$?" -eq $SUCCESS ]; then
echo "$1 может быть установлен."
else
echo "$1 — установка невозможна!"
fi
echo
}> "$1.test" # Перенаправление вывода в файл.
echo "Результаты проверки rpm-архива находятся в файле $1.test"
# За дополнительной информацией по ключам команды rpm см. man rpm.
exit 0
</source>
В отличие от групп команд в (круглых скобках), описаных выше, вложенные блоки кода, заключённые в {фигурные скобки} исполняются в пределах того же процесса, что и сам скрипт (т.е. не вызывают запуск дочернего процесса — subshell)!
 
<big>'''''{ } \;'''''</big> — ''pathname'', полное имя файла (т.е. путь к файлу и его имя). Чаще всего используется совместно с командой [[find]].
Обратите внимание на то, что символ <big>''''';'''''</big> , которым завершается ключ ''-exec'' команды [[find]], экранируется обратным слэшем. Это необходимо, чтобы предотвратить его интерпретацию.
* <big>'''''[ ]'''''</big> — Квадратные скобки('''''[ ]''''')
Проверка истинности выражения, заключенного в квадратные скобки <big>'''''[ ]'''''</big>. Примечательно, что <big>'''''['''''</big> является частью встроенной команды ''test'' (и её синонимом), и не имеет никакого отношения к "внешней" утилите /usr/bin/test.
 
<big>'''''[[ ]]'''''</big> — Проверка истинности выражения, заключенного между '''[[ ]]''' (зарезервированное слово интерпретатора).
 
<big>'''''[ ]'''''</big> — Элемент массива. При работе с массивами в квадратных скобках указывается порядковый номер того элемента массива, к которому производится обращение.
<source lang="bash">
Array[1]=slot_1
echo ${Array[1]}
</source>
<big>'''''[ ]'''''</big> — диапазон символов. В регулярных выражениях, в квадратных скобках задаётся диапазон искомых символов.
* <big>'''''>'''''</big>, <big>'''''&>'''''</big>, <big>'''''>&'''''</big>, <big>'''''>>'''''</big>, <big>'''''<'''''</big> — Перенаправление.
 Конструкция <big>''scriptname''</big> '''''>''''' <big>''filename''</big> перенаправляет вывод '''scriptname''' в файл '''filename'''. Если файл '''filename''' уже существовал, то его прежнее содержимое будет утеряно.
 Конструкция <big>''command''</big> '''''&>''''' <big>''filename''</big> перенаправляет вывод команды '''command''', как с ''stdout'', так и с ''stderr'', в файл '''filename'''.
 Конструкция <big>''command''</big> '''''>&2''''' перенаправляет вывод с ''stdout'' на ''stderr''.
 Конструкция <big>''scriptname''</big> '''''>>''''' <big>''filename''</big> добавляет вывод '''scriptname''' к файлу '''filename'''. Если задано имя несуществующего файла, то он создаётся.
<big>'''''<<'''''</big> — Перенаправление ввода на встроенный документ.
 
<big>'''''(command)>'''''</big>, <big>'''''<(command)'''''</big> — Подстановка процесса.
В операциях сравнения, символы "<" и ">" обозначают операции сравнения строк. А так же операции сравнения целых чисел.
<big>'''''<'''''</big>, <big>'''''>'''''</big> — Посимвольное ASCII-сравнение.
<source lang="bash">
veg1=carrots
veg2=tomatoes
if [[ "$veg1" < "$veg2" ]]; then
echo "Не смотря на то, что в словаре слово $veg1 предшествует слову $veg2,"
echo "это никак не отражает мои кулинарные предпочтения."
else
echo "Интересно. Каким словарем вы пользуетесь?"
fi
</source>
<big>'''''\<'''''</big>,<big>'''''\>'''''</big> — границы отдельных слов в регулярных выражениях.
<source lang="bash">
bash$ grep '\<the\>' textfile
</source>
* <big>'''''|'''''</big> — Конвейер(pipe).
Передает вывод предыдущей команды на ввод следующей или на вход командного интерпретатора shell. Этот метод часто используется для связывания последовательности команд в единую цепочку.
<source lang="bash">
echo ls -l | sh
# Передаёт вывод "echo ls -l" командному интерпретатору shell,
# тот же результат даёт простая команда "ls -l".
cat *.lst | sort | uniq
# Объединяет все файлы ".lst", сортирует содержимое и удаляет повторяющиеся строки.
</source>
{| class="wikitable"
|-
| Конвейеры (еще их называют каналами) — это классический способ взаимодействия процессов, с помощью которого ''stdout'' одного процесса перенаправляется на ''stdin'' другого. Обычно используется совместно с командами вывода, такими как [[cat]] или [[echo]], от которых поток данных поступает в "фильтр" (команда, которая на входе получает данные, преобразует их и обрабатывает).
<source lang="bash">cat $filename | grep $search_word</source>
|}
В конвейер могут объединяться и сценарии на языке командной оболочки.
<source lang="bash">
#!/bin/bash
# uppercase.sh : Преобразование вводимых символов в верхний регистр.
tr 'a-z' 'A-Z'
# Диапазоны символов должны быть заключены в кавычки
# чтобы предотвратить порождение имен файлов от однобуквенных имен файлов.
exit 0
</source>
А теперь попробуем объединить в конвейер команду [[Ls_—_Команда_печати_содержимого_каталога|ls -l]] с этим сценарием:
[[File:Uppercase_0.PNG|center|600px]]
Выход ''stdout'' каждого процесса в конвейере должен читаться на входе ''stdin'' последующим, в конвейере, процессом. Если этого не делается, то поток данных блокируется, в результате конвейер будет работать не так как ожидается!
<source lang="bash">
cat file1 file2 | ls -l | sort # Вывод команды "cat file1 file2" будет утерян.
</source>
Конвейер исполняется в дочернем процессе, а посему — не имеет доступа к переменным сценария.
<source lang="bash">
variable="initial_value"
echo "new_value" | read variable
echo "variable = $variable" # variable = initial_value
</source>
Если одна из команд в конвейере завершается аварийно, то это приводит каварийному завершению работы всего конвейера!
 
<big>'''''>|'''''</big> — принудительное перенаправление, даже если установлен ключ ''noclobber option''.
* <big>'''''||'''''</big> — логическая операция OR(логическое ИЛИ).
В опрециях проверки условий, оператор <big>'''''||'''''</big> возвращает 0 ('''success'''), если один из операндов имеет значение ''true'' (ИСТИНА).
* <big>'''''&'''''</big> — Амперсанд
Выполнение задачи в фоне. Команда, за которой стоит <big>'''''&'''''</big>, будет исполняться в фоновом режиме.
<source lang="bash">
bash$ sleep 10 &
[1] 850
[1]+ Done sleep 10
</source>
В сценариях команды, и даже циклы могут запускаться в фоновом режиме.
 '''Пример.''': '''''Запуск цикла в фоновом режиме'''''
<source lang="bash">
#!/bin/bash
# background-loop.sh
for i in 1 2 3 4 5 6 7 8 9 10 # Первый цикл.
do
echo -n "$i "
done & # Запуск цикла в фоне.
# Иногда возможны случаи выполнения этого цикла после второго цикла.
echo # Этот 'echo' иногда не отображается на экране.
for i in 11 12 13 14 15 16 17 18 19 20 # Второй цикл.
do
echo -n "$i "
done
echo # Этот 'echo' иногда не отображается на экране.
# ======================================================
# Ожидается, что данный сценарий выведет следующую последовательность:
# 1 2 3 4 5 6 7 8 9 10
# 11 12 13 14 15 16 17 18 19 20
# Иногда возможен такой вариант:
# 11 12 13 14 15 16 17 18 19 20
# 1 2 3 4 5 6 7 8 9 10 bozo $
# (Второй 'echo' не был выполнен. Почему?)
# Изредка возможен такой вариант:
# 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
# (Первый 'echo' не был выполнен. Почему?)
# Крайне редко встречается и такое:
# 11 12 13 1 2 3 4 5 6 7 8 9 10 14 15 16 17 18 19 20
# Второй цикл начал исполняться раньше первого.
exit 0
</source>
Команда, исполняемая в пределах сценария в фоне, может подвесить сценарий, ожидая нажатия клавиши. К счастью, это легко "лечится".
* <big>'''''&&'''''</big> — логическая операция ''AND'' (логическое И).
В операциях проверки условий, оператор <big>'''''&&'''''</big> возвращает 0 ('''success''') тогда, и только тогда, когда оба операнда имеют значение ''true''(ИСТИНА).
* <big>'''''-'''''</big> — Знак дефиса (''-'')
Префикс ключа. С этого символа начинаются опциональные ключи команд:
<source lang="bash">
COMMAND -[Option1][Option2][...]
ls -al
sort -dfu $filename
set -- $variable

if [ $file1 -ot $file2 ];then
echo "Файл $file1 был создан раньше чем $file2."
fi
if [ "$a" -eq "$b" ]; then
echo "$a равно $b."
fi
if [ "$c" -eq 24 -a "$d" -eq 47 ]; then
echo "$c равно 24, а $d равно 47."
fi
</source>
<big>'''''-'''''</big> — перенаправление из/в ''stdin'' или ''stdout''.
<source lang="bash">
(cd /source/directory && tar cf - . ) | (cd /dest/directory && tar xpvf -)
# Перемещение полного дерева файлов и подкаталогов из одной директории в другую
# спасибо Алану Коксу (Alan Cox) <a.cox@swansea.ac.uk>, за небольшие поправки
# 1) cd /source/directory Переход в исходный каталог, содержимое которого будет перемещено
# 2) && "И-список": благодаря этому все последующие команды будут выполнены
# только тогда, когда 'cd' завершится успешно
# 3) tar cf - . ключом 'c' архиватор 'tar' создает новый архив,
# ключом 'f' (file) и последующим '-' задается файл архива -- stdout,
# в архив помещается текущий каталог ('.') с вложенными подкаталогами.
# 4) | конвейер с ...
# 5) ( ... ) subshell-ом (дочерним экземпляром командной оболочки)
# 6) cd /dest/directory Переход в каталог назначения.
# 7) && "И-список", см. выше
# 8) tar xpvf - Разархивирование ('x'), с сохранением атрибутов "владельца" и прав доступа ('p') к файлам,
# с выдачей более подробных сообщений на stdout ('v'),
# файл архива -- stdin ('f' с последующим '-').
#
# Примечательно, что 'x' -- это команда, а 'p', 'v' и 'f' -- ключи
# Во как!
# Более элегантный вариант:
# cd source-directory
# tar cf - . | (cd ../target-directory; tar xzf -)
#
#cp -a /source/directory /dest имеет тот же эффект.

bunzip2 linux-2.4.3.tar.bz2 | tar xvf -
# --разархивирование tar-файла-- | --затем файл передается утилите "tar"--
# Если у вас утилита "tar" не поддерживает работу с "bunzip2",
# тогда придется выполнять работу в два этапа, с использованием конвейера.
# Целью данного примера является разархивирование тарбола (tar.bz2) с исходными текстами ядра.
</source>
Обратите внимание, что в этом контексте <big>'''''-'''''</big> - не самостоятельный оператор Bash, а скорее опция, распознаваемая некоторыми утилитами Unix (такими как [[tar]], [[cat]] и т.п.), которые выводят результаты своей работы в ''stdout''.
<source lang="bash">
bash$ echo "whatever" | cat -
whatever
</source>
В случае, когда ожидается имя файла, тогда <big>'''''-'''''</big> перенаправляет вывод на ''stdout'' (вспомните пример с [[Tar|tar cf]]) или принимает ввод с ''stdin''.
<source lang="bash">
bash$ file
Usage: file [-bciknvzL] [-f namefile] [-m magicfiles] file...
</source>
Сама по себе команда [[file]] без параметров завершается с сообщением об ошибке.
Добавим символ <big>'''''-'''''</big> и получим более полезный результат. Это заставит командный интерпретатор ожидать ввода от пользователя.
<source lang="bash">
bash$ file -
abc
standard input: ASCII text
bash$ file -
#!/bin/bash
standard input: Bourne-Again shell script text executable
</source>
Теперь команда принимает ввод пользователя со ''stdin'' и анализирует его.
Используя передачу ''stdout'' по конвейеру другим командам, можно выполнять довольно эффектные трюки, например вставка строк в начало файла.
С помощью команды [[diff]] — находить различия между одним файлом и частью другого:
<source lang="bash"> grep Linux file1 | diff file2 -</source>
И наконец пример использования служебного символа <big>'''''-'''''</big> с командой [[tar]].
 '''Пример.''': '''''Резервное архивирование всех файлов, которые были изменены втечение последних суток'''''
<source lang="bash">
#!/bin/bash
# Резервное архивирование (backup) всех файлов в текущем каталоге,
# которые были изменены в течение последних 24 часов
# в тарболл (tarball) (.tar.gz - файл).
BACKUPFILE=backup
archive=${1:-$BACKUPFILE}
# На случай, если имя архива в командной строке не задано,
# т.е. по-умолчанию имя архива -- "backup.tar.gz"
tar cvf - `find . -mtime -1 -type f -print` > $archive.tar
gzip $archive.tar
echo "Каталог $PWD заархивирован в файл \"$archive.tar.gz\"."
# Stephane Chazelas заметил, что вышеприведенный код будет "падать"
# если будет найдено слишком много файлов
# или если имена файлов будут содержать символы пробела.
# Им предложен альтернативный код:
# -------------------------------------------------------------------
# find . -mtime -1 -type f -print0 | xargs -0 tar rvf "$archive.tar"
# используется версия GNU утилиты "find".
# find . -mtime -1 -type f -exec tar rvf "$archive.tar" '{}' \;
# более универсальный вариант, хотя и более медленный,
# зато может использоваться в других версиях UNIX.
# -------------------------------------------------------------------
exit 0
</source>
 Могут возникнуть конфликтные ситуации между опреатором перенаправления <big>'''''-'''''</big> и именами файлов, начинающимися с символа "-". Поэтому сценарий должен проверять имена файлов и предварять их префиксом пути, например, ''./-FILENAME'', ''$PWD/-FILENAME'' или ''$PATHNAME/-FILENAME''.
Если значение переменной начинается с символа "-", то это тоже может быть причиной появления ошибок.
<source lang="bash">
var="-n"
echo $var
# В данном случае команда приобретет вид "echo -n" и ничего не выведет.
</source>
<big>'''''-'''''</big> — предыдущий рабочий каталог. Команда cd - выполнит переход в предыдущий рабочий каталог, путь к которому хранится в переменной окружения $OLDPWD.
Не путайте оператор "-" (предыдущего рабочего каталога) с оператором <big>'''''-'''''</big> (переназначения). Ещё раз напомню, что интерпретация символа "-" зависит от контекста, в котором он употребляется.
<big>'''''-'''''</big> — Знак минус в арифметических операциях.
* <big>'''''='''''</big> — Символ равно ('''''=''''').
Символ равно (<big>'''''='''''</big>) выступает в качестве оператора присваивания.
<source lang="bash">
a=28
echo $a # 28
</source>
В зависимости от контекста применения, символ <big>'''''='''''</big> может выступать в качестве оператора сравнения.
* <big>'''''+'''''</big> — Символ плюс ('''''+''''').
Символ плюс (<big>'''''+'''''</big>) выступает в качестве оператора сложения в арифметических операциях. В зависимости от контекста применения, символ <big>'''''+'''''</big> может выступать как оператор регулярного выражения.
<big>'''''+'''''</big> - Ключ (опция). Дополнительный флаг для ключей (опций) команд. Отдельные внешние и встроенные команды используют символ "+" для разрешения некоторой опции, а символ "-" — для запрещения.
* <big>'''''%'''''</big> — Символ процента ('''''%''''').
Модуль (остаток от деления) — арифметическая операция. В зависимости от контекста применения, символ <big>'''''%'''''</big> может выступать в качестве шаблона.
* <big>'''''~'''''</big> — Символ тильда ('''''~''''').
Соответствует содержимому внутренней переменной $HOME. ~bozo — домашний каталог пользователя bozo, а команда [[Ls_—_Команда_печати_содержимого_каталога|ls ~bozo]] выведет содержимое его домашнего каталога. '''~/''' — это домашний каталог текущего пользователя, а команда [[Ls_—_Команда_печати_содержимого_каталога|ls ~/]] выведет содержимое домашнего каталога текущего пользователя.
<source lang="bash">
bash$ echo ~bozo
/home/bozo
bash$ echo ~/home/bozo
bash$ echo ~/
/home/bozo/
bash$ echo ~:
/home/bozo:
bash$ echo ~nonexistent-user
~nonexistent-user
</source>
<big>'''''~+'''''</big> — текущий рабочий каталог. Соответствует содержимому внутренней переменной $PWD.
 
<big>'''''~-'''''</big> — предыдущий рабочий каталог. Соответствует содержимому внутренней переменной $OLDPWD.
* <big>'''''^'''''</big> — Символ карет ('''''^''''').
Начало-строки. В регулярных выражениях символ "^" задает начало строки текста. Управляющий символ '''изменяет поведение терминала или управляет выводом текста'''. Управляющий символ набирается с клавиатуры как комбинация '''''CONTROL + <клавиша>'''''.
# '''''Ctrl-B''''' — Курсор — на одну позицию назад (без стирания символа).
# '''''Ctrl-C''''' — Прерывание выполнения процесса.
# '''''Ctrl-D''''' — Выход из командного интерпретатора (log out) (аналог команды [[exit]])."EOF" (признак конца файла). Этот символ может выступать в качестве завершающего привводе с ''stdin''.
# '''''Ctrl-G''''' — "BEL" (звуковой сигнал -- "звонок").
# '''''Ctrl-H''''' — Backspace ("забой") — удаление предыдущего символа.
# '''''Ctrl-I''''' — Горизонтальная табуляция.
# '''''Ctrl-J''''' — Перевод строки.
# '''''Ctrl-K''''' — Вертикальная табуляция.
# '''''Ctrl-L''''' — Перевод формата (очистка экрана (окна) терминала). Аналогична команде [[clear]].
# '''''Ctrl-M''''' — Возврат каретки.
# '''''Ctrl-Q''''' — Resume (XON). Эта комбинация "восстанавливает" работу ''stdin'' терминала.
# '''''Ctrl-S''''' — Suspend (XOFF). Эта комбинация "замораживает" ''stdin'' терминала. (Для восстановления "работоспособности" — используйте комбинацию '''''Ctrl-Q''''')
# '''''Ctrl-U''''' — Стирание строки ввода.
# '''''Ctrl-Z''''' — Приостановка процесса.
<source lang="bash">
#!/bin/bash
# Вставка символа Ctl-H в строку.
a="^H^H" # Два символа Ctl-H (backspace).
echo "abcdef"
# abcdef
echo -n "abcdef$a "
# abcd f
# Пробел в конце ^ ^ двойной шаг назад.
echo -n "abcdef$a" # abcdef
# Пробела в конце нет, backspace не работает (почему?).
# Результаты могут получиться совсем не те, что вы ожидаете.
echo; echo
</source>

<source lang="bash">
#!/bin/bash
# Спасибо Lee Maschmeyer, за этот пример.
read -n 1 -s -p $'Control-M — переводит курсор в начало этой же строки. Нажмите клавишу Enter. \x0d'
# Разумеется, что, 'x0d' — это # шестнадцатиричный эквивалент '''''Ctrl-M'''''.
echo >&2 # Перевод строки
read -n 1 -s -p $'Control-J — переводит курсор в начало другой строки. \x0a'
echo >&2 # Control-J — это перевод строки.
read -n 1 -s -p $'А Control-K\x0b — вниз.'
echo >&2 # Control-K — это вертикальная табуляция.
exit 0
</source>
* <big>''''' '''''</big> — Символ пробела (''''' ''''').
Пробельный символ используется как разделитель команд или переменных. В качестве пробельного символа могут выступать — собственно пробел (space), символ табуляции, символ перевода строки, символ возврата каретки или комбинация из вышеперечисленных символов. В некоторых случаях, таких как присваивание значений переменным, использование пробельных символов недопустимо. Пустые строки никак не обрабатываются командным интерпретатором и могут свободно использоваться для визуального выделения отдельных блоков сценария. '''''$IFS''''' — переменная специального назначения. Содержит символы-разделители полей, используемые некоторыми командами. По-умолчанию — пробельные символы.

== Переменные и параметры. Введение. ==
Переменные — это одна из основ любого языка программирования. Они участвуют в арифметических операциях, в синтаксическом анализе строк и совершенно необходимы для абстрагирования каких-либо величин с помощью символических имен. Физически переменные представляют собой ни что иное как участки памяти, в которые записана некоторая информация.
=== Подстановка переменных ===
Когда интерпретатор встречает в тексте сценария имя переменной, то он вместо него подставляет значение этой переменной. Поэтому ссылки на переменные называются подстановкой переменных.
* <big>'''''$'''''</big>
 
Необходимо всегда помнить о различиях между именем переменной и её значением. Если variable1 — это имя переменной, то $variable1 — это ссылка на её значение. "Чистые" имена переменных, без префикса $, могут использоваться только при объявлении переменной, при присваивании переменной некоторого значения, при удалении (сбросе), при экспорте и в особых случаях — когда переменная представляет собой название сигнала. Присваивание может производится с помощью символа = (например: var1=27), инструкцией read и в заголовке цикла (for var2 in 1 2 3).
 
Заключение ссылки на переменную в двойные кавычки (" ") никак не сказывается на работе механизма подстановки. Этот случай называется "частичные кавычки", иногда можно встретить название "нестрогие кавычки". Одиночные кавычки (' ') заставляют интерпретатор воспринимать ссылку на переменную как простой набор символов, потому в одинарных кавычках операции подстановки не производятся. Этот случай называется "полные", или "строгие" кавычки.
 
Примечательно, что написание $variable фактически является упрощенной формой написания ${variable}. Более строгая форма записи ${variable} может с успехом использоваться в тех случаях, когда применение упрощенной формы записи порождает сообщения о синтаксических ошибках.
 '''Пример''': '''''Присваивание значений переменным и подстановка значений переменных.'''''
<source lang="bash">
#!/bin/bash
# Присваивание значений переменным и подстановка значений переменных
a=375
hello=$a
#-------------------------------------------------------------------------
# Использование пробельных символов
# с обеих сторон символа "=" присваивания недопустимо.
# Если записать "VARIABLE =value",
# то интерпретатор попытается выполнить команду "VARIABLE" с параметром "=value".
# Если записать "VARIABLE= value",
# то интерпретатор попытается установить переменную окружения "VARIABLE" в ""
# и выполнить команду "value".
#-------------------------------------------------------------------------
echo hello # Это не ссылка на переменную, выведет строку "hello".
echo $hello
echo ${hello} # Идентично предыдущей строке.
echo "$hello"
echo "${hello}"
echo
hello="A B C D"
echo $hello
# A B C D
echo "$hello" # A B C D
# Здесь вы сможете наблюдать различия в выводе echo $hello и echo "$hello".
# Заключение ссылки на переменную в кавычки сохраняет пробельные символы.
echo
echo '$hello' # $hello
# Внутри одинарных кавычек не производится подстановка значений переменных,
# т.е. "$" интерпретируется как простой символ.
# Обратите внимание на различия, существующие между этими типами кавычек.
hello= # Запись пустого значения в переменную.
echo "\$hello (пустое значение) = $hello"
# Обратите внимание: запись пустого значения — это не то же самое,
# что сброс переменной, хотя конечный результат — тот же.
# --------------------------------------------------------------
# Допускается присваивание нескольких переменных в одной строке,
# если они отделены пробельными символами.
# Внимание! Это может снизить читабельность сценария и оказаться непереносимым.
var1=variable1 var2=variable2 var3=variable3
echo
echo "var1=$var1 var2=$var2 var3=$var3"
# Могут возникнуть проблемы с устаревшими версиями "sh".
# --------------------------------------------------------------
echo; echo
numbers="один два три"
other_numbers="1 2 3"
# Если в значениях переменных встречаются пробелы,
# то использование кавычек обязательно.
echo "numbers = $numbers"
echo "other_numbers = $other_numbers" # other_numbers = 1 2 3
echo
echo "uninitialized_variable = $uninitialized_variable"
# Неинициализированная переменная содержит "пустое" значение.
uninitialized_variable= # Объявление неинициализированной переменной (то же, что и присваивание пустого значения)
echo "uninitialized_variable = $uninitialized_variable" # Переменная содержит "пустое" значение.
uninitialized_variable=23 # Присваивание.
unset uninitialized_variable # Сброс.
echo "uninitialized_variable = $uninitialized_variable" # Переменная содержит "пустое" значение.
echo
exit 0
</source>
Неинициализированная переменная хранит "пустое" значение - не ноль! Использование неинициализированных переменных может приводить к ошибкам разного рода в процессе исполнения. Не смотря на это в арифметических операциях допускается использовать неинициализированные переменные.
<source lang="bash">
echo "$uninitialized" # (пустая строка)
let "uninitialized += 5" # Прибавить 5.
echo "$uninitialized" # 5
# Заключение:
# Неинициализированные переменные не имеют значения, однако
# в арифметических операциях за значение таких переменных принимается число 0.
# Это недокументированная (и возможно непереносимая) возможность.
</source>
=== Присваивание значений переменным ===
* <big>'''''='''''</big>
 
Оператор присваивания (пробельные символы до и после оператора — недопустимы).
Не путайте с операторами сравнения ''='' и ''-eq''!
Обратите внимание: символ <big>'''''='''''</big> может использоваться как в качестве оператора присваивания, так и в качестве оператора сравнения, конкретная интерпретация зависит от контекста применения.
 '''Пример''': '''''Простое присваивание.'''''
<source lang="bash">
#!/bin/bash
# Явные переменные
echo
# Когда перед именем переменной не употребляется символ '$'?
# В операциях присваивания.
# Присваивание
a=879
echo "Значение переменной \"a\" — $a."
# Присваивание с помощью ключевого слова 'let'
let a=16+5
echo "Значение переменной \"a\" теперь стало равным: $a."
echo
# В заголовке цикла 'for' (своего рода неявное присваивание)
echo -n "Значения переменной \"a\" в цикле: "
for a in 7 8 9 11
do
echo -n "$a "
done
echo
echo
# При использовании инструкции 'read' (тоже одна из разновидностей присваивания)
echo -n "Введите значение переменной \"a\" "
read a
echo "Значение переменной \"a\" теперь стало равным: $a."
echo
exit 0
</source>
 
 '''Пример''': '''''Присваивание значений переменным простое и замаскированное.'''''
<source lang="bash">
#!/bin/bash
a=23 # Простейший случай
echo $a
b=$a
echo $b
# Теперь немного более сложный вариант (подстановка команд).
a=`echo Hello!` # В переменную 'a' попадает результат работы команды 'echo'
echo $a
# Обратите внимание на восклицательный знак (!) в подстанавливаемой команде
# этот вариант не будет работать при наборе в командной строке,
# поскольку здесь используется механизм "истории команд" BASH
# Однако, в сценариях, механизм истории команд запрещен.
a=`ls -l` # В переменную 'a' записывается результат работы команды 'ls -l'
echo $a # Кавычки отсутствуют, удаляются лишние пробелы и пустые строки.
echo
echo "$a" # Переменная в кавычках, все пробелы и пустые строки сохраняются
exit 0
</source>
 
<source lang="bash">
# Взято из /etc/rc.d/rc.local
R=$(cat /etc/redhat-release)
arch=$(uname -m)
</source>

=== Переменные Bash не имеют типа ===
В отличие от большинства других языков программирования, Bash не производит разделения переменных по "типам". По сути, переменные Bash являются строковыми переменными, но, в зависимости от контекста, Bash допускает целочисленную арифметику с переменными. Определяющим фактором здесь служит содержимое переменных.
 '''Пример''': '''''Целое число или строка?'''''
<source lang="bash">
#!/bin/bash
# int-or-string.sh: Целое число или строка?
a=2334 # Целое число.
let "a += 1"
echo "a = $a " # a = 2335
echo # Всё ещё целое число.
b=${a/23/BB} # замена "23" на "BB".
# Происходит трансформация числа в строку.
echo "b = $b"
# b = BB35
declare -i b # Явное указание типа здесь не поможет.
echo "b = $b" # b = BB35
let "b += 1" # BB35 + 1 =
echo "b = $b" # b = 1
echo
c=BB34
echo "c = $c" # c = BB34
d=${c/BB/23} # замена "BB" на "23".
# Переменная $d становится целочисленной.
echo "d = $d" # d = 2334
let "d += 1" # 2334 + 1 =
echo "d = $d" # d = 2335echo
echo
# А что происходит с "пустыми" переменными?
e=""
echo "e = $e" # e =
let "e += 1" # Арифметические операции допускают использование "пустых" переменных?
echo "e = $e" # e = 1
echo # "Пустая" переменная становится целочисленной.
# А что происходит с необъявленными переменными?
echo "f = $f" # f =
let "f += 1" # Арифметические операции допустимы?
echo "f = $f" # f = 1
echo # Необъявленная переменная трансформируется в целочисленную.
# Переменные Bash не имеют типов.
exit 0
</source>
 
Отсутствие типов — это и благословение и проклятие. С одной стороны — отсутствие типов делает сценарии более гибкими(чтобы повеситься — достаточно иметь веревку!) и облегчает чтение кода. С другой — является источником потенциальных ошибок и поощряет привычку к "неряшливому" программированию.
Бремя отслеживания типа той или иной переменной полностью лежит на плечах программиста. Bash не будет делать это за вас!

=== Специальные типы переменных ===
* <big>'''''локальные переменные'''''</big>
Переменные, область видимости которых ограничена блоком кода или телом функции (см. также локальные переменные в функциях)
 
 
* <big>'''''переменные окружения'''''</big>
Переменные, которые затрагивают командную оболочку и порядок взаимодействия с пользователем.
В более общем контексте, каждый процесс имеет некоторое "окружение" (среду исполнения), т.е. набор переменных, к которым процесс может
обращаться за получением определенной информации. В этом смысле командная оболочка подобна любому другому процессу.
Каждый раз, когда запускается командный интерпретатор, для него создаются переменные, соответствующие переменным окружения. Изменение переменных или добавление новых переменных окружения заставляет оболочку обновить свои переменные, и все дочерние процессы (и команды, исполняемые ею)наследуют это окружение.
Пространство, выделяемое под переменные окружения, ограничено. Создание слишком большого количества переменных
окружения или одной переменной, которая занимает слишком большое пространство, может привести к возникновению определённых проблем.
<source lang="bash">
bash$ eval "`seq 10000 | sed -e 's/.*/export var&=ZZZZZZZZZZZZZZ/'`"
bash$ du
bash: /usr/bin/du: Argument list too long
</source>
Если сценарий изменяет переменные окружения, то они должны "экспортироваться", т.е. передаваться окружению, локальному по отношению к сценарию. Эта функция возложена на команду ''export''.
Сценарий может экспортировать переменные только дочернему процессу, т.е.командам и процессам запускаемым из данного сценария.
Сценарий, запускаемый из командной строки '''''не может''''' экспортировать переменные "наверх" командной оболочке. Дочерний процесс не может
экспортировать переменные родительскому процессу.
* <big>'''''позиционные параметры'''''</big>
Аргументы, передаваемые скрипту из командной строки — $0, $1, $2, $3..., где $0 — это название файла сценария, $1 — это первый аргумент, $2 — второй, $3 — третий и так далее. Аргументы, следующие за $9, должны заключаться в фигурные скобки, например: ${10}, ${11}, ${12}. 
Специальные переменные '''''$*''''' и '''''$@''''' содержат все позиционные параметры (аргументы командной строки).
 '''Пример''': '''''Позиционные параметры.'''''
<source lang="bash">
#!/bin/bash
# Команда вызова сценария должна содержать по меньшей мере 10 параметров, например
# ./scriptname 1 2 3 4 5 6 7 8 9 10
MINPARAMS=10
echo
echo "Имя файла сценария: \"$0\"."
# Для текущего каталога добавит ./
echo "Имя файла сценария: \"`basename $0`\"."
# Добавит путь к имени файла (см. 'basename')
echo
if [ -n "$1" ] # Проверяемая переменная заключена в кавычки.
then
echo "Параметр #1: $1" # необходимы кавычки для экранирования символа #
fi
if [ -n "$2" ]
then
echo "Параметр #2: $2"
fi
if [ -n "$3" ]
then
echo "Параметр #3: $3"
fi
if [ -n "${10}" ] # Параметры, следующие за $9 должны заключаться в фигурные скобки
then
echo "Параметр #10: ${10}"
fi
echo "-----------------------------------"
echo "Все аргументы командной строки: "$*""
if [ $# -lt "$MINPARAMS" ]
then
echo
echo "Количество аргументов командной строки должно быть не менее $MINPARAMS !"
fi
echo
exit 0
</source>
''Скобочная нотация'' позиционных параметров даёт довольно простой способ обращения к последнему аргументу, переданному в сценарий из командной строки. Такой способ подразумевает использование косвенной адресации.
<source lang="bash">
args=$# # Количество переданных аргументов.
lastarg=${!args} # Обратите внимание: lastarg=${!$#} неприменимо.
</source>
В сценарии можно предусмотреть различные варианты развития событий, в зависимости отимени сценария. Для этого сценарий должен проанализировать аргумент $0 -- имя файласценария. Это могут быть и имена символических ссылок на файл сценария.
Если сценарий ожидает передачи аргументов в командной строке, то при их отсутствии он получит "пустые" переменные, что может вызвать нежелательный
побочный эффект. Один из способов борьбы с подобными ошибками — добавить дополнительный символ в обеих частях операции присваивания,
где используются аргументы командной строки.
<source lang="bash">
variable1_=$1_# Это предотвратит появление ошибок, даже при отсутствии входного аргумента.
critical_argument01=$variable1_
# Дополнительные символы всегда можно "убрать" позднее.
# Это может быть сделано примерно так:
variable1=${variable1_/_/} # Побочный эффект возникает только если имя переменной # $variable1_ будет начинаться с символа "_".
# Здесь используется один из вариантов подстановки параметров, обсуждаемых далее.
# Отсутствие шаблона замены приводит к удалению.
# Более простой способ заключается
# в обычной проверке наличия позиционного параметра.
if [ -z $1 ]; then
exit $POS_PARAMS_MISSING
fi
</source>

 '''Пример''': '''''wh, whois выяснение имени домена.'''''
<source lang="bash">
#!/bin/bash
# Команда 'whois domain-name' выясняет имя домена на одном из 3 серверов:
# ripe.net, cw.net, radb.net
# Разместите этот скрипт под именем 'wh' в каталоге /usr/local/bin
# Требуемые символические ссылки:
# ln -s /usr/local/bin/wh /usr/local/bin/wh-ripe
# ln -s /usr/local/bin/wh /usr/local/bin/wh-cw
# ln -s /usr/local/bin/wh /usr/local/bin/wh-radb
if [ -z "$1" ]
then
echo "Порядок использования: `basename $0` [domain-name]"
exit 65
fi
case `basename $0` in
# Проверка имени скрипта и, соответственно, имени сервера
"wh" ) whois $1@whois.ripe.net;;
"wh-ripe") whois $1@whois.ripe.net;;
"wh-radb") whois $1@whois.radb.net;;
"wh-cw" ) whois $1@whois.cw.net;;
* ) echo "Порядок использования: `basename $0` [domain-name]";;
esac
exit 0
</source>
Команда shift "сдвигает" позиционные параметры, в результате чего парметры "сдвигаются" на одну позицию влево.
 $1 <--- $2, $2 <--- $3, $3 <--- $4, и т.д. 
Прежний аргумент $1 теряется, но аргумент $0 (имя файла сценария) остаётся без изменений. Если вашему сценарию передаётся большое количество входных аргументов, то команда shift позволит вам получить доступ к аргументам, с порядковым номером больше 9, без использования {фигурных скобок}.
 '''Пример''': '''''Использование команды shift.'''''
<source lang="bash">
#!/bin/bash
# Использование команды 'shift' с целью перебора всех аргументов командной строки.
# Назовите файл с этим сценарием, например "shft",
# и вызовите его с набором аргументов, например:
# ./shft a b c def 23 skidoo
until [ -z "$1" ] # До тех пор пока не будут разобраны все входные аргументы...
do
echo -n "$1 "
shift
done
echo # Дополнительная пустая строка.
exit 0
</source>
Команда ''shift'' может применяться и к входным аргументам функций.

== Кавычки ==
Кавычки, ограничивающие строки с обеих сторон, служат для предотвращения интерпретации специальных символов, которые могут находиться в строке. Символ называется "специальным", если он несет дополнительную смысловую нагрузку, например символ шаблона — <big>'''*'''</big>.
<source lang="bash">
bash$ ls -l [Vv]*
-rw-rw-r-- 1 bozo bozo 324 Apr 2 15:05 VIEWDATA.BAT
-rw-rw-r-- 1 bozo bozo 507 May 4 14:25 vartrace.sh
-rw-rw-r-- 1 bozo bozo 539 Apr 14 17:11 viewdata.sh
bash$ ls -l '[Vv]*'
ls: [Vv]*: No such file or directory
</source>
Некоторые программы и утилиты могут вызываться с дополнительными параметрами,содержащими специальными символы, поэтому очень важно предотвратить интерпретацию передаваемых параметров командной оболочкой, позволяя сделать это вызываемой программой.
<source lang="bash">
bash$ grep '[Пп]ервая' *.txt
file1.txt:Это первая строка в file1.txt.
file2.txt:Это Первая строка в file2.txt.
</source>
Примечательно, что "не окавыченный" вариант команды grep [Пп]ервая *.txt будет правильно исполняться в Bash, но не в tcsh.
Вообще, желательно использовать двойные кавычки (<big>" "</big>) при обращении к переменным. Это предотвратит интерпретацию специальных символов, которые могут содержаться в именах переменных, за исключением <big>$</big>, <big>`</big>(обратная кавычка) и <big>\</big> (escape — обратный слэш).
То, что символ <big>$</big> попал в разряд исключений, позволяет выполнять обращение к переменным внутри строк, ограниченных двойными кавычками ("$variable"), т.е. выполнять подстановку значений переменных.
Двойные кавычки могут быть использованы для предотвращения разбиения строки на слова. Заключение строки в кавычки приводит к тому, что она передаётся как один аргумент, даже если она содержит пробельные символы-разделители.
<source lang="bash">
variable1="a variable containing five words"
COMMAND This is $variable1 # Исполнение COMMAND с 7 входными аргументами:
# "This" "is" "a" "variable" "containing" "five" "words"
COMMAND "This is $variable1"
# Исполнение COMMAND с одним входным аргументом:# "This is a variable containing five words"
variable2="" # Пустая переменная.
COMMAND $variable2 $variable2 $variable2 # Исполнение COMMAND без аргументов.
COMMAND "$variable2" "$variable2" "$variable2" # Исполнение COMMAND с 3 "пустыми" аргументами.
COMMAND "$variable2 $variable2 $variable2" # Исполнение COMMAND с 1 аргументом (и 2 пробелами).
</source>
Заключение в кавычки аргументов команды [[echo]] необходимо только в том случае, когда разбиение на отдельные слова сопряжено с определенными трудностями.
 '''Пример''': '''''Вывод "причудливых" переменных.'''''
<source lang="bash">
#!/bin/bash
# weirdvars.sh: Вывод "причудливых" переменных
var="'(]\\{}\$\""
echo $var # '(]\{}$"
echo "$var" # '(]\{}$" Никаких различий.
echo
IFS='\'
echo $var # '(] {}$" \ символ-разделитель преобразован в пробел.
echo "$var" # '(]\{}$"
# Примеры выше предоставлены S.C.
exit 0
</source>
Одиночные кавычки (<big>' '</big>) схожи по своему действию с двойными кавычками, только не допускают обращение к переменным, поскольку специальный символ "$" внутри одинарных кавычек воспринимается как обычный символ. Внутри одиночных кавычек, любой специальный символ, заисключением ', интерпретируется как простой символ. Одиночные кавычки ("строгие, или полные кавычки") следует рассматривать как более строгий вариант, чем двойные кавычки ("нестрогие, или неполные кавычки").
Поскольку внутри одиночных кавычек даже экранирующий (<big>\</big>) символ воспринимается как обычный символ, попытка вывести одиночную кавычку внутри строки, ограниченной одинарными кавычками, не даст желаемого результата.
<source lang="bash">
echo "Why can't I write 's between single quotes"
echo
# Обходной метод.
echo 'Why can'\''t I write '"'"'s between single quotes'
# |-------| |----------| |-----------------------|
# Три строки, ограниченных одинарными кавычками,
# и экранированные одиночные кавычки между ними.
# Пример любезно предоставлен Stephane Chazelas.
</source>
'''''Экранирование''''' — это способ заключения в кавычки одиночного символа. Экранирующий (escape)символ (<big>\</big>) сообщает интерпретатору, что следующий за ним символ должен восприниматься как обычный символ. С отдельными командами и утилитами, такими как [[echo]] и [[sed]], экранирующий символ может применяться для получения обратного эффекта — когда обычные символы при экранировании приобретают специальное значение.
 '''Специальное назначение некоторых экранированных символов, используемых совместно с [[echo]] и [[sed]]'''
* <big>'''\n'''</big> — перевод строки (новая строка)
* <big>'''\r'''</big> — перевод каретки
* <big>'''\t'''</big> — табуляция
* <big>'''\v'''</big> — вертикальная табуляция
* <big>'''\b'''</big> — забой (backspace)
* <big>'''\a'''</big> — "звонок" (сигнал)
* <big>'''\0xx'''</big> — ASCII-символ с кодом 0xx в восьмеричном виде
 '''Пример''': '''''Экранированные символы.'''''
<source lang="bash">
#!/bin/bash
# escaped.sh: экранированные символы
echo; echo
echo "\v\v\v\v" # Вывод последовательности символов \v\v\v\v.
# Для вывода экранированных символов следует использовать ключ -e.
echo "============="
echo "ВЕРТИКАЛЬНАЯ ТАБУЛЯЦИЯ"
echo -e "\v\v\v\v" # Вывод 4-х вертикальных табуляций.
echo "=============="
echo "КАВЫЧКИ"
echo -e "\042" # Выводит символ " (кавычки с восьмеричным кодом ASCII 42).
echo "=============="
# Конструкция $'\X' делает использование ключа -e необязательным.
echo; echo "НОВАЯ СТРОКА И ЗВОНОК"
echo $'\n' # Перевод строки.
echo $'\a' # Звонок (сигнал).
echo "==============="
echo "КАВЫЧКИ"
# Bash версии 2 и выше допускает использование конструкции $'\nnn'.
# Обратите внимание: здесь под '\nnn' подразумевается восьмеричное значение.
echo $'\t \042 \t' # Кавычки (") окруженные табуляцией.
# В конструкции $'\xhhh' допускается использовать и шестнадцатеричные значения.
echo $'\t \x22 \t' # Кавычки (") окруженные табуляцией.
# Спасибо Greg Keraunen, за это примечание.
# Ранние версии Bash допускали употребление конструкции в виде '\x022'.
echo "==============="
echo
# Запись ASCII-символов в переменную.
# ----------------------------------------
quote=$'\042' # запись символа " в переменную.
echo "$quote Эта часть строки ограничена кавычками, $quote а эта — нет."
echo
# Конкатенация ASCII-символов в переменную.
triple_underline=$'\137\137\137' # 137 — это восьмеричный код символа '_'.
echo "$triple_underline ПОДЧЕРКИВАНИЕ $triple_underline"
echo
ABC=$'\101\102\103\010' # 101, 102, 103 это A, B и C соответственно.
echo $ABC
echo; echo
escape=$'\033' # 033 — восьмеричный код экранирующего символа.
echo "\"escape\" выводится как $escape"
# вывод отсутствует.
echo; echo
exit 0
</source>
* <big>'''\"'''</big> — кавычки
<source lang="bash">
echo "Привет" # Привет
echo "Он сказал: \"Привет\"." # Он сказал: "Привет".
</source>
* <big>'''\$'''</big> — символ доллара (если за комбинацией символов \$ следует имя переменной, то она не будет разыменована)
<source lang="bash">
echo "\$variable01" # выведет $variable01
</source>
* <big>'''\\'''</big> — обратный слэш
<source lang="bash">
echo "\\" # выведет \
# Тогда как...
echo "\" # Приведёт к выводу вторичного приглашения к вводу.
# В сценариях — порождает сообщение об ошибке.
</source>
Поведение символа <big>\</big> сильно зависит от того экранирован ли он, ограничен ли кавычками или находится внутри конструкции подстановки команды или во вложенном документе.
<source lang="bash">
# Простое экранирование и кавычки
echo \z # z
echo \\z # \z
echo '\z' # \z
echo '\\z' # \\z
echo "\z" # \z
echo "\\z" # \z
# Подстановка команды
echo `echo \z` # z
echo `echo \\z` # z
echo `echo \\\z` # \z
echo `echo \\\\z` # \z
echo `echo \\\\\\z` # \z
echo `echo \\\\\\\z` # \\z
echo `echo "\z"` # \z
echo `echo "\\z"` # \z
# Встроенный документ
cat <<EOF
\z
EOF # \z
cat <<EOF
\\z
EOF # \z
# Эти примеры предоставил Stephane Chazelas.
</source>
Отдельные символы в строке, которая записывается в переменную, могут быть экранированы, исключение составляет сам экранирующий символ.
<source lang="bash">
variable=\
echo "$variable"
# Не работает - дает сообщение об ошибке:
# test.sh: : command not found
# В "чистом" виде экранирующий (escape) символ не может быть записан в переменную.
# Фактически, в данном примере, происходит экранирование символа перевода строки
# в результате получается такая команда: variable=echo "$variable"
# ошибочное присваивание
variable=\
23skidoo
echo "$variable" # 23skidoo
# Здесь все в порядке, поскольку вторая строка
# является нормальным, с точки зрения присваивания, выражением.
variable=\
# \^ За escape-символом следует пробел
echo "$variable" # пробел
variable=\\ # \
variable=\\\
echo "$variable"
# Не работает - сообщение об ошибке:
# test.sh: \: command not found
#
# Первый escape-символ экранирует второй, а третий оказывается неэкранированным,
# результат тот же, что и в первом примере.
variable=\\\\
echo "$variable" # \\
# Второй и четвертый escape-символы экранированы.
# Это нормально.
</source>
Экранирование пробелов предотвращает разбиение списка аргументов командной строки на отдельные аргументы.
<source lang="bash">
file_list="/bin/cat /bin/gzip /bin/more /usr/bin/less /usr/bin/emacs-20.7"
# Список файлов как аргумент(ы) командной строки.
# Добавить два файла в список и вывести список.
ls -l /usr/X11R6/bin/xsetroot /sbin/dump $file_listecho "-------------------------------------------------------------------------"
# Что произойдет, если экранировать пробелы в списке?
ls -l /usr/X11R6/bin/xsetroot\ /sbin/dump\ $file_list
# Ошибка: первые три файла будут "слиты" воедино
# и переданы команде 'ls -l' как один аргумент
# потому что два пробела, разделяющие аргументы (слова) — экранированы.
</source>
Кроме того, escape-символ позволяет писать многострочные команды. Обычно, каждая команда занимает одну строку, но escape-символ позволяет экранировать символ перевода строки, в результате чего одна команда может занимать несколько строк.
<source lang="bash">
(cd /source/directory && tar cf - . ) | \
(cd /dest/directory && tar xpvf -)
# Команда копирования дерева каталогов.
# Разбита на две строки для большей удобочитаемости.
# Альтернативный вариант:
tar cf - -C /source/directory . |
tar xpvf - -C /dest/directory
# См. примечание ниже.
# (Спасибо Stephane Chazelas.)
</source>
Если строка сценария заканчивается символом создания конвейера <big>|</big>, то необходимость в применении символа <big>\</big>, для экранирования перевода строки, отпадает. Тем не менее, считается хорошим тоном, всегда использовать символ <big>\</big> в конце промежуточных строк многострочных команд.
<source lang="bash">
echo "foo
bar"
#foo
#bar
echo
echo 'foo
bar' # Никаких различий.
echo
echo foo\
bar # Перевод строки экранирован.
#foobar
echo
echo "foo\
bar" # Внутри "нестрогих" кавычек символ "\" интерпретируется как экранирующий.
#foobar
echo
echo 'foo\
bar' # В "строгих" кавычках обратный слэш воспринимается как обычный символ.
#foo\
#bar
# Примеры предложены Stephane Chazelas.
</source>

== Завершение и код завершения ==
<blockquote>
''...эта часть Bourne shell покрыта мраком, тем не менее все пользуются ею''. ©Chet Ramey
</blockquote>
Команда [[exit]] может использоваться для завершения работы сценария, точно так же как и в программах на языке C. Кроме того, она может возвращать некоторое значение, которое может быть проанализировано вызывающим процессом. Каждая команда возвращает ''код завершения'' (иногда код завершения называют ''возвращаемым значением''). В случае успеха команда должна возвращать 0, а в случае ошибки — ненулевое значение, которое, как правило, интерпретируется как код ошибки. Практически все команды и утилиты Unix возвращают 0 в случае успешного завершения, но имеются и исключения из правил.
 
Аналогичным образом ведут себя функции, расположенные внутри сценария, и сам сценарий, возвращая код завершения. Код, возвращаемый функцией или сценарием, определяется кодом возврата последней команды. Команде [[exit]] можно явно указать код возврата, в виде: exit ''nnn'', где ''nnn'' — это код возврата (число в диапазоне 0 - 255).
Когда работа сценария завершается командой [[exit]] без параметров, то код возврата сценария определяется кодом завершения последней исполненной команды (не считая саму команду [[exit]]).
<source lang="bash">
#!/bin/bash
COMMAND_1
...
# Сценарий вернет код завершения последней команды.
COMMAND_LAST
exit
</source>
Эквивалентный вариант — ''exit $?'' или можно вообще опустить команду [[exit]].
<source lang="bash">
#!/bin/bash
COMMAND_1
...
# Сценарий вернет код завершения последней команды.
COMMAND_LAST
exit $?

#!/bin/bash
COMMAND1
...
# Сценарий вернет код завершения последней команды.
COMMAND_LAST
</source>
Код возврата последней команды хранится в специальной переменной <big>$?</big>. После исполнения кодафункции, переменная <big>$?</big> хранит код завершения последней команды, исполненной в функции. Таким способом в Bash передаётся "значение, возвращаемое" функцией. После завершения работы сценария, код возврата можно получить, обратившись из командной строки к переменной <big>$?</big>, т.е. это будет код возврата последней команды, исполненной в сценарии.
 '''Пример''': '''''Завершение / код завершения.'''''
<source lang="bash">
#!/bin/bash
echo hello
echo $? # код возврата = 0, поскольку команда выполнилась успешно.
lskdf # Несуществующая команда.
echo $? # Ненулевой код возврата, поскольку команду выполнить не удалось.
echo
exit 113 # Явное указание кода возврата 113.
# Проверить можно, если набрать в командной строке "echo $?"
# после выполнения этого примера.
# В соответствии с соглашениями, 'exit 0' указывает на успешное завершение,
# в то время как ненулевое значение означает ошибку.
</source>
Переменная <big>$?</big> особенно полезна, когда необходимо проверить результат исполнения команды.
Символ <big>!</big>, может выступать как логическое "''НЕ''" для инверсии кода возврата.
 '''Пример''': '''''Использование символа "!" для логической инверсии кода возврата.'''''
<source lang="bash">
#!/bin/bash
true # встроенная команда "true".
echo "код возврата команды \"true\" = $?" # 0
! true
echo "код возврата команды \"! true\" = $?" # 1
# Обратите внимание: символ "!" от команды необходимо отделять пробелом.
# !true вызовет сообщение об ошибке "command not found"
# Спасибо S.C.
</source>
В отдельных случаях коды возврата должны иметь предопределённые значения и не должны задаваться пользователем.

== Проверка условий ==
Практически любой язык программирования включает в себя условные операторы, предназначенные для проверки условий, чтобы выбрать тот или иной путь развития событий в зависимости от этих условий. В Bash, для проверки условий, имеется команда [[test]], различного вида скобочные операторы и условный оператор '''''if/then'''''.
=== Конструкции проверки условий ===
* Оператор '''''if/then''''' проверяет — является ли код завершения списка команд 0 (поскольку 0 означает "успех"!), и если это так, то выполняет одну, или более, команд, следующие за словом '''''then'''''.
* Существует специальная команда — '''''[''''' (левая квадратная скобка). Она является синонимом команды [[test]], и является встроенной командой (т.е. более эффективной, в смысле производительности). Эта команда воспринимает свои аргументы как выражение сравнения или как файловую проверку и возвращает код завершения в соответствии с результатами проверки(0 — истина, 1 — ложь).
* Начиная с версии 2.02, Bash предоставляет в распоряжение программиста конструкцию '''''[[ ... ]]''''', расширенный вариант команды [[test]], которая выполняет сравнение способом более знакомым программистам, пишущим на других языках программирования. Обратите внимание: '''''[[''''' — это зарезервированное слово, а не команда!
Bash исполняет '''''<nowiki>[[ $a -lt $b ]]</nowiki>''''' как один элемент, который имеет код возврата!
 Круглые скобки '''''(( ... ))''''' и предложение '''''let ...''''' так же возвращают код 0, если результатом арифметического выражения является ненулевое значение. Таким образом, арифметические выражения могут участвовать в операциях сравнения.
 ''Предложение let "1<2" возвращает 0 (так как результат сравнения "1<2" — "1", или "истина")(( 0 && 1 )) возвращает 1 (так как результат операции "0 && 1" — "0", или "ложь")''
* Условный оператор ''if'' проверяет код завершения любой команды, а не только результат выражения, заключенного в квадратные скобки.
<source lang="bash">
if cmp a b &> /dev/null # Подавление вывода.
then echo "Файлы a и b идентичны."
else echo "Файлы a и b имеют различия."
fi
if grep -q Bash file
then echo "Файл содержит, как минимум, одно слово Bash."
fi
word=Linux
letter_sequence=inu
if echo "$word" | grep -q "$letter_sequence"
# Подавление вывода ключом "-q" в команде grep.
then
echo "Последовательность $letter_sequence обнаружена в слове $word"
else
echo "Последовательность $letter_sequence, в слове $word не найдена"
fi

if COMMAND_WHOSE_EXIT_STATUS_IS_0_UNLESS_ERROR_OCCURRED
then echo "Команда выполнена успешно."
else echo "Обнаружена ошибка при выполнении команды."
fi
</source>
* Оператор ''if/then'' допускает наличие вложенных проверок.
<source lang="bash">
if echo "Следующий *if* находится внутри первого *if*."
if [[ $comparison = "integer" ]]
then (( a 

'''''Это детальное описание конструкции "if-test" любезно предоставлено Stephane Chazelas.'''''
 '''Пример''': '''''Что есть "истина"?'''''
<source lang="bash">
#!/bin/bash
echo
echo "Проверяется \"0\""
if [ 0 ] # ноль
then
echo "0 — это истина."
else
echo "0 — это ложь."
fi # 0 — это истина.
echo
echo "Проверяется \"1\""
if [ 1 ] # единица
then
echo "1 — это истина."
else
echo "1 — это ложь."
fi # 1 — это ложь.
echo
echo "Testing \"-1\""
if [ -1 ] # минус один
then
echo "-1 — это истина."
else
echo "-1 — это ложь."
fi # -1 — это истина.
echo
echo "Проверяется \"NULL\""
if [ ] # NULL (пустое условие)
then
echo "NULL — это истина."
else
echo "NULL — это ложь."
fi # NULL — это ложь.
echo
echo "Проверяется \"xyz\""
if [ xyz ] # строка
then
echo "Случайная строка — это истина."
else
echo "Случайная строка — это ложь."
fi # Случайная строка — это истина.
echo
echo "Проверяется \"\$xyz\""
if [ $xyz ] # Проверка, если $xyz это null, но...
# только для неинициализированных переменных.
then
echo "Неинициализированная переменная — это истина."
else
echo "Неинициализированная переменная — это ложь."
fi # Неинициализированная переменная — это ложь.
echo
echo "Проверяется \"-n \$xyz\""
if [ -n "$xyz" ] # Более корректный вариант.
then
echo "Неинициализированная переменная — это истина."
else
echo "Неинициализированная переменная — это ложь."
fi # Неинициализированная переменная — это ложь.
echo
xyz= # Инициализирована пустым значением.
echo "Проверяется \"-n \$xyz\""
if [ -n "$xyz" ]
then
echo "Пустая переменная — это истина."
else
echo "Пустая переменная — это ложь."
fi # Пустая переменная — это ложь.
echo
# Когда "ложь" истинна?
echo "Проверяется \"false\""
if [ "false" ] # это обычная строка "false".
then
echo "\"false\" — это истина." # и она истинна.
else
echo "\"false\" — это ложь."
fi # "false" — это истина.
echo
echo "Проверяется \"\$false\"" # Опять неинициализированная переменная.
if [ "$false" ]
then
echo "\"\$false\" — это истина."
else
echo "\"\$false\" — это ложь."
fi # "$false" — это ложь.
# Теперь мы получили ожидаемый результат.
echo
exit 0
</source>
'''''Упражнение'''''
Объясните результаты, полученные в примере ''Что есть "истина"?''
<source lang="bash">
if [ condition-true ]
then
command 1
command 2
...
else # Необязательная ветка (можно опустить, если в ней нет необходимости).
# Дополнительный блок кода,
# исполняемый в случае, когда результат проверки — "ложь".
command 3 command 4 ...
fi
</source>
Когда ''if'' и ''then'' располагаются в одной строке, то конструкция ''if'' должна завершаться точкой с запятой. И ''if'', и ''then'' - это '''''зарезервированные слова'''''. '''''Зарезервированные слова''''' начинают инструкцию, которая должна быть завершена прежде, чем в той же строке появится новая инструкция.
<source lang="bash">
if [ -x "$filename" ]; then
</source>
* Else if и elif
''elif'' — это краткая форма записи конструкции else if. Применяется для построения многоярусных инструкций ''if/then''.
<source lang="bash">
if [ condition1 ]
then
command1
command2
command3
elif [ condition2 ]
# То же самое, что и else if
then
command4
command5
else
default-command
fi
</source>
Конструкция ''if test condition-true'' является точным эквивалентом конструкции ''if [ condition-true]'', где левая квадратная скобка ''['' выполняет те же действия, что и команда [[test]]. Закрывающая правая квадратная скобка '']'' не является абсолютно необходимой, однако, более новые версии Bash требуют её наличие.
Команда [[test]] — это встроенная команда Bash, которая выполняет проверки файлов и производит сравнение строк. Таким образом, в Bash-скриптах, команда [[test]] не вызывает внешнюю ('''''/usr/bin/test''''') утилиту, которая является частью пакета sh-utils. Аналогично, ''['' не производит вызов утилиты '''''/usr/bin/[''''', которая является символической ссылкой на '''''/usr/bin/test'''''.
<source lang="bash">
bash$ type test
test is a shell builtin
bash$ type '['
[ is a shell builtin
bash$ type '[['
[[ is a shell keyword
bash$ type ']]'
]] is a shell keyword
bash$ type ']'
bash: type: ]: not found
</source>

 '''Пример''': '''''Эквиваленты команды test — /usr/bin/test, [ ], и /usr/bin/['''''
<source lang="bash">
#!/bin/bash
echo
if test -z "$1"
then
echo "Аргументы командной строки отсутствуют."
else
echo "Первый аргумент командной строки: $1."
fi
echo
if /usr/bin/test -z "$1" # Даёт тот же результат, что и встроенная команда "test".
then
echo "Аргументы командной строки отсутствуют."
else
echo "Первый аргумент командной строки: $1."
fi
echo
if [ -z "$1" ] # Функционально идентично вышеприведенному блоку кода.
# if [ -z "$1" эта конструкция должна работать, но...
# Bash выдает сообщение об отсутствующей закрывающей скобке.
then
echo "Аргументы командной строки отсутствуют."
else
echo "Первый аргумент командной строки: $1."
fi
echo
if /usr/bin/[ -z "$1" # Функционально идентично вышеприведенному блоку кода.
# if /usr/bin/[ -z "$1" ] # Работает, но выдает сообщение об ошибке.
then
echo "Аргументы командной строки отсутствуют."
else
echo "Первый аргумент командной строки: $1."
fi
echo
exit 0
</source>
Конструкция <big><nowiki>[[ ]]</nowiki></big> более универсальна, по сравнению с <big><nowiki>[ ]</nowiki></big> . Этот расширенный вариант команды [[test]] перекочевал в Bash из ''ksh88''. Внутри этой конструкции не производится никакой дополнительной интерпретации имён файлов и не производится разбиение аргументов на отдельные слова, но допускается подстановка параметров и команд.
<source lang="bash">
file=/etc/passwd
if [[ -e $file ]]
then
echo "Файл паролей найден."
fi
</source>
Конструкция <big><nowiki>[[...]]</nowiki></big> более предпочтительна, нежели <big><nowiki>[...]</nowiki></big>, поскольку поможет избежать некоторых логических ошибок. Например, операторы '''''&&''''', '''''||''''', '''''<''''' и '''''>''''' внутри <big><nowiki>[[ ]]</nowiki></big> вполне допустимы, в то время как внутри <big><nowiki>[ ]</nowiki></big> порождают сообщения об ошибках!
Строго говоря, после оператора ''if'', ни команда [[test]], ни квадратные скобки ( <big><nowiki>[]</nowiki></big> или <big><nowiki>[[ ]]</nowiki></big> ) не являются обязательными.
<source lang="bash">
dir=/home/bozo
if cd "$dir" 2>/dev/null; then # "2>/dev/null" подавление вывода сообщений об ошибках.
echo "Переход в каталог $dir выполнен."
else
echo "Невозможно перейти в каталог $dir."
fi
</source>
Инструкция ''if COMMAND'' возвращает код возврата команды ''COMMAND''. Точно так же, условие, находящееся внутри квадратных скобок может быть проверено без использования оператора ''if''.
<source lang="bash">
var1=20
var2=22
[ "$var1" -ne "$var2" ] && echo "$var1 не равно $var2"
home=/home/bozo
[ -d "$home" ] || echo "каталог $home не найден."
</source>
Внутри <big><nowiki>(())</nowiki></big> производится вычисление арифметического выражения. Если результатом вычислений является ноль, то возвращается 1, или "ложь". Ненулевой результат даёт код возврата 0, или "истина". То есть полная противоположность инструкциям [[test]] и [ ], обсуждавшимся выше.
 '''Пример''': '''''Арифметические выражения внутри (( ))'''''
<source lang="bash">
#!/bin/bash
# Проверка арифметических выражений.
# Инструкция (( ... )) вычисляет арифметические выражения.
# Код возврата противоположен коду возврата инструкции [ ... ] !
(( 0 ))
echo "Код возврата \"(( 0 ))\": $?." # 1(( 1 ))
(( 1 ))
echo "Код возврата \"(( 1 ))\": $?." # 0
(( 5 > 4 )) # true
echo "Код возврата \"(( 5 > 4 ))\": $?." # 0
(( 5 > 9 )) # false
echo "Код возврата \"(( 5 > 9 ))\": $?." # 1
(( 5 - 5 )) # 0
echo "Код возврата \"(( 5 - 5 ))\": $?." # 1
(( 5 / 4 )) # Деление, всё в порядке
echo "Код возврата \"(( 5 / 4 ))\": $?." # 0
(( 1 / 2 )) # Результат деления < 1.
echo "Код возврата \"(( 1 / 2 ))\": $?." # Округляется до 0. #1
(( 1 / 0 )) 2>/dev/null # Деление на 0.
echo "Код возврата \"(( 1 / 0 ))\": $?." # 1
# Для чего нужна инструкция "2>/dev/null" ?
# Что произойдет, если её убрать?
# Попробуйте убрать её и выполнить сценарий.
exit 0
</source>

=== Операции проверки файлов ===
Возвращает ''true'' если...
* <big>-e</big> — файл существует
* <big>-f</big> — ''обычный'' файл (не каталог и не файл устройства!)
* <big>-s</big> — ненулевой размер файла
* <big>-d</big> — файл является каталогом
* <big>-b</big> — файл является блочным устройством (floppy, cdrom и т.п.)
* <big>-c</big> — файл является символьным устройством (клавиатура, модем, звуковая карта и т.п.)
* <big>-p</big> — файл является каналом
* <big>-h</big> — файл является символической ссылкой
* <big>-L</big> — файл является символической ссылкой
* <big>-S</big> — файл является сокетом
* <big>-t</big> — файл (дескриптор) связан с терминальным устройством
Этот ключ может использоваться для проверки — является ли файл стандартным устройством ввода ''stdin'' ([ -t 0 ]) или стандартным устройством вывода ''stdout'' ([ -t 1 ]).
* <big>-r</big> — файл доступен для чтения (пользователю, запустившему сценарий)
* <big>-w</big> — файл доступен для записи (пользователю, запустившему сценарий)
* <big>-x</big> — файл доступен для исполнения (пользователю, запустившему сценарий)
* <big>-g</big> — set-group-id (sgid) флаг для файла или каталога установлен
Если для каталога установлен флаг sgid, то файлы, создаваемые в таком каталоге, наследуют идентификатор группы каталога, который может не совпадать с идентификатором группы, к которой принадлежит пользователь, создавший файл. Это может быть полезно для каталогов, в которых хранятся файлы, общедоступные для группы пользователей.
* <big>-u</big> — set-user-id (suid) флаг для файла установлен
Установленный флаг suid приводит к изменению привилегий запущенного процесса на привилегии владельца исполняемого файла. Исполняемые файлы, владельцем которых является root, с установленным флагом set-user-id запускаются с привилегиями root, даже если их запускает обычный пользователь.
Это может оказаться полезным для некоторых программ(таких как ''pppd'' и ''cdrecord''), которые осуществляют доступ к аппаратной части компьютера. В случае отсутствия флага suid, программы не смогут быть запущены рядовым пользователем, не обладающим привилегиями root.
''-rwsr-xr-t 1 root 178236 Oct 2 2000 /usr/sbin/pppd''
Файл с установленным флагом suid отображается с включенным флагом ''s'' в поле прав доступа.
* <big>-k</big> — флаг sticky bit (бит фиксации) установлен
Общеизвестно, что флаг "sticky bit" — это специальный тип прав доступа к файлам. Программы сустановленным флагом "sticky bit" остаются в системном кэше после своего завершения,обеспечивая тем самым более быстрый запуск программы. Если флаг установлен для каталога, то это приводит к ограничению прав на запись. Установленный флаг "sticky bit" отображается в виде символа ''t'' в поле прав доступа.
''drwxrwxrwt 7 root 1024 May 19 21:26 tmp/''
Если пользователь не является владельцем каталога , с установленным "sticky bit", но имеет право на запись в каталог, то он может удалять только те файлы в каталоге, владельцем которых он является. Это предотвращает удаление и перезапись "чужих" файлов в общедоступных каталогах, таких как /tmp.
* <big>-O</big> — вы являетесь владельцем файла
* <big>-G</big> — вы принадлежите к той же группе, что и файл
* <big>-N</big> — файл был модифицирован с момента последнего чтения
* <big>f1 -nt f2</big> — файл f1 более новый, чем f2
* <big>f1 -ot f2</big> — файл f1 более старый, чем f2
* <big>f1 -ef f2</big> — файлы f1 и f2 являются "жесткими" ссылками на один и тот же файл
* <big>!</big> — "НЕ" — логическое отрицание (инверсия) результатов всех вышеприведенных проверок(возвращается ''true'' если условие отсутствует).

 '''Пример''': '''''Проверка "битых" ссылок.'''''
<source lang="bash">
#!/bin/bash
# broken-link.sh
# Автор Lee Bigelow <ligelowbee@yahoo.com>
# Используется с его разрешения.
#Сценарий поиска "битых" ссылок и их вывод в "окавыченном" виде
#таким образом они могут передаваться утилите xargs для дальнейшей обработки :)
#например. broken-link.sh /somedir /someotherdir|xargs rm
#
#На всякий случай приведу лучший метод:
#
#find "somedir" -type l -print0|\
#xargs -r0 file|\
#grep "broken symbolic"|
#sed -e 's/^\|: *broken symbolic.*$/"/g'
#
#но это не чисто BASH-евский метод, а теперь сам сценарий.
#Внимание! будьте осторожны с файловой системой /proc и циклическими ссылками!
##############################################################
#Если скрипт не получает входных аргументов,
#то каталогом поиска является текущая директория
#В противном случае, каталог поиска задается из командной строки
####################
[ $# -eq 0 ] && directorys=`pwd` || directorys=$@
#Функция linkchk проверяет каталог поиска
#на наличие в нём ссылок на несуществующие файлы, и выводит их имена.
#Если анализируемый файл является каталогом,
#то он передаётся функции linkcheck рекурсивно.
##########
linkchk () {
for element in $1/*; do
[ -h "$element" -a ! -e "$element" ] && echo \"$element\"
[ -d "$element" ] && linkchk $element
# Само собой, '-h' проверяет символические ссылки, '-d' -- каталоги.
done
}
#Вызов функции linkchk для каждого аргумента командной строки,
#если он является каталогом. Иначе выводится сообщение об ошибке
#и информация о порядке пользования скриптом.
################
for directory in $directorys; do
if [ -d $directory ]
then linkchk $directory
else
echo "$directory не является каталогом"
echo "Порядок использования: $0 dir1 dir2 ..."
fi
done
exit 0
</source>

=== Операции сравнения ===
'''''Сравнение целых чисел''''':
* <big>-eq</big> — равно
if [ "$a" -eq "$b" ]
* <big>-ne</big> — не равно
if [ "$a" -ne "$b" ]
* <big>-gt</big> — больше
if [ "$a" -gt "$b" ]
* <big>-ge</big> — больше или равно
if [ "$a" -ge "$b" ]
* <big>-lt</big> — меньше
if [ "$a" -lt "$b" ]
* <big>-le</big> — меньше или равно
if [ "$a" -le "$b" ]
* <big><</big> — меньше (внутри двойных круглых скобок )
(("$a" < "$b"))
* <big><=</big> — меньше или равно (внутри двойных круглых скобок)
(("$a" <= "$b"))
* <big>></big> — больше (внутри двойных круглых скобок )
(("$a" > "$b"))
* <big>>=</big> — больше или равно(внутри двойных круглых скобок )
(("$a" >= "$b"))

'''''Cравнение строк''''':
* <big>=</big> — равно
if [ "$a" = "$b" ]
* <big>==</big> — равно. Синоним оператора =.
if [ "$a" == "$b" ]
<source lang="bash">
[[ $a == z* ]] # истина, если $a начинается с символа "z" (сравнение по шаблону)
[[ $a == "z*" ]] # истина, если $a равна z*
[ $a == z* ] # имеют место подстановка имён файлов и разбиение на слова
[ "$a" == "z*" ] # истина, если $a равна z*
# Спасибо S.C.
</source>
* <big>!=</big> — не равно
if [ "$a" != "$b" ]
Этот оператор используется при поиске по шаблону внутри [[ ... ]]
* <big><</big> — меньше, в смысле величины ASCII-кодов
if [[ "$a" < "$b" ]]
if [ "$a" \< "$b" ]
Обратите внимание! Символ "<" необходимо экранировать внутри [ ]
* <big>></big> — больше, в смысле величины ASCII-кодов
if [[ "$a" > "$b" ]]
if [ "$a" \> "$b" ]
Обратите внимание! Символ ">" необходимо экранировать внутри [ ]
* <big>-z</big> — строка "пустая", т.е. имеет нулевую длину
* <big>-n</big> — строка не "пустая"
Оператор ''-n'' требует, чтобы строка была заключена в кавычки внутри квадратных скобок. Как правило, проверка строк, не заключенных в кавычки, оператором ''! -z'', или просто указание строки без кавычек внутри квадратных скобок, проходит нормально, однако это небезопасная, с точки зрения отказоустойчивости, практика. Всегда заключайте проверяемую строку в кавычки.
 '''Пример''': '''''Операции сравнения.'''''
<source lang="bash">
#!/bin/bash
a=4
b=5
# Здесь переменные "a" и "b" могут быть как целыми числами, так и строками.
# Здесь наблюдается некоторое размывание границ
# между целочисленными и строковыми переменными,
# поскольку переменные в Bash не имеют типов.
# Bash выполняет целочисленные операции над теми переменными,
# которые содержат только цифры
# Будьте внимательны!
echo
if [ "$a" -ne "$b" ]
then
echo "$a не равно $b"
echo "(целочисленное сравнение)"
fi
echo
if [ "$a" != "$b" ]
then
echo "$a не равно $b."
echo "(сравнение строк)"
# "4" != "5"
# ASCII 52 != ASCII 53
fi
# Оба варианта, "-ne" и "!=", работают правильно.
echo
exit 0
</source>
 '''Пример''': '''''Проверка — является ли строка пустой'''''
<source lang="bash">
#!/bin/bash
# str-test.sh: Проверка пустых строк и строк, не заключенных в кавычки,
# Используется конструкция if [ ... ]
# Если строка не инициализирована, то она не имеет никакого определенного значения.
# Такое состояние называется "null" (пустая) (это не то же самое, что ноль).
if [ -n $string1 ] # $string1 не была объявлена или инициализирована.
then
echo "Строка \"string1\" не пустая."
else
echo "Строка \"string1\" пустая."
fi
# Неверный результат.
# Выводится сообщение о том, что $string1 не пустая,
# не смотря на то, что она не была инициализирована.
echo
# Попробуем ещё раз.
if [ -n "$string1" ] # На этот раз, переменная $string1 заключена в кавычки.
then
echo "Строка \"string1\" не пустая."
else
echo "Строка \"string1\" пустая."
fi # Внутри квадратных скобок заключайте строки в кавычки!
echo
if [ $string1 ] # Опустим оператор -n.
then
echo "Строка \"string1\" не пустая."
else
echo "Строка \"string1\" пустая."
fi
# Всё работает прекрасно.
# Квадратные скобки — [ ], без посторонней помощи определяют, что строка пустая.
# Тем не менее, хорошим тоном считается заключать строки в кавычки ("$string1").
# Как указывает Stephane Chazelas,
# if [ $string 1 ] один аргумент "]"
# if [ "$string 1" ] два аргумента, пустая "$string1" и "]"
echo
string1=initialized
if [ $string1 ] # Опять, попробуем строку без ничего.
then
echo "Строка \"string1\" не пустая."
else
echo "Строка \"string1\" пустая."
fi
# И снова получим верный результат.
# И опять-таки, лучше поместить строку в кавычки ("$string1"), поскольку...
echo
string1="a = b"
if [ $string1 ] # И снова, попробуем строку без ничего..
then
echo "Строка \"string1\" не пустая."
else
echo "Строка \"string1\" пустая."
fi
# Строка без кавычек даёт неверный результат!
exit 0
# Спасибо Florian Wisser, за предупреждение.
</source>
 '''Пример''': '''''zmore'''''
<source lang="bash">
#!/bin/bash
#Просмотр gz-файлов с помощью утилиты 'more'
NOARGS=65
NOTFOUND=66
NOTGZIP=67
if [ $# -eq 0 ] # то же, что и: if [ -z "$1" ]
# $1 должен существовать, но может быть пустым: zmore "" arg2 arg3
then
echo "Порядок использования: `basename $0` filename" >&2
# Сообщение об ошибке на stderr.
exit $NOARGS
# Код возврата 65 (код ошибки).
fi
filename=$1
if [ ! -f "$filename" ] # Кавычки необходимы на тот случай, если имя файла содержит пробелы.
then
echo "Файл $filename не найден!" >&2
# Сообщение об ошибке на stderr.
exit $NOTFOUND
fi
if [ ${filename##*.} != "gz" ]
# Квадратные скобки нужны для выполнения подстановки значения переменной
then
echo "Файл $1 не является gz-файлом!"
exit $NOTGZIP
fi
zcat $1 | more
# Используется утилита 'more' (очень похожа на 'less').
# Последние версии 'more' могут просматривать сжатые файлы.
# Можно вставить 'more' или 'less', если пожелаете.
exit $? # Сценарий возвращает код возврата, полученный по конвейеру.
# На самом деле команда "exit $?" не является обязательной,
# так как работа скрипта завершится здесь в любом случае.
</source>
'''''Построение сложных условий проверки''''':
* <big>-a</big> — логическое И (and)
''exp1 -a exp2'' возвращает ''true'', если оба выражения, и ''exp1'', и ''exp2'' истинны.
* <big>-o</big> — логическое ИЛИ (or)
''exp1 -o exp2'' возвращает ''true'', если хотябы одно из выражений, ''exp1'' или ''exp2'' истинно.
Они похожи на операторы Bash '''&&''' и '''||''', употребляемые в двойных квадратных скобках.
''<nowiki>[[ condition1 && condition2 ]]</nowiki>''
Операторы ''-o'' и ''-a'' употребляются совместно с командой [[test]] или внутри одинарных квадратных скобок.
''if [ "$exp1" -a "$exp2" ]''

=== Вложенные условные операторы if/then ===
Операторы проверки условий ''if/then'' могут быть вложенными друг в друга. Конечный результат будет таким же как если бы результаты всех проверок были объединены оператором '''&&'''.
<source lang="bash">
if [ condition1 ]
then
if [ condition2 ]
then
do-something # Только если оба условия "condition1" и "condition2" истинны.
fi
fi
</source>

=== Проверка степени усвоения материала ===
Для запуска X-сервера может быть использован файл xinitrc. Этот файл содержит некоторое число операторов if/then. Ниже приводится отрывок из этого файла.
<source lang="bash">
if [ -f $HOME/.Xclients ]; then
exec $HOME/.Xclients
elif [ -f /etc/X11/xinit/Xclients ]; then
exec /etc/X11/xinit/Xclients
else
# failsafe settings. Although we should never get here
# (we provide fallbacks in Xclients as well) it can't hurt.
xclock -geometry 100x100-5+5 &
xterm -geometry 80x50-50+150 &
if [ -f /usr/bin/netscape -a -f /usr/share/doc/HTML/index.html ]; then
netscape /usr/share/doc/HTML/index.html &
fi
fi
</source>
Объясните действия условных операторов в вышеприведённом отрывке, затем просмотрите файл /etc/X11/xinit/xinitrc и проанализируйте его. Возможно вам придется обратиться
к разделам, посвящённым [[grep]], [[sed]] и регулярным выражениям.

== Операции и смежные темы ==
=== Операторы ===
* <big>'''Присваивание'''</big>
''variable assignment'' 
Инициализация переменной или изменение её значения.
 
<big>'''='''</big> — Универсальный оператор присваивания, пригоден как для сравнения целых чисел, так и для сравнения строк.
Пусть вас не смущает, что оператор присваивания ("="), по своему внешнему виду, совпадает с оператором сравнения (=).
<source lang="bash">
# Здесь знак "=" выступает в качестве оператора сравнения
if [ "$string1" = "$string2" ]
# if [ "X$string1" = "X$string2" ] более отказоустойчивый вариант,
# предохраняет от "сваливания" по ошибке в случае, когда одна из переменных пуста.
# (добавленные символы "X" компенсируют друг друга.)
then
command
fi
</source>
* <big>'''Арифметические операторы'''</big>
<big>'''+'''</big> — Сложение
<big>'''-'''</big> — Вычитание
<big>'''*'''</big> — Умножение
<big>'''/'''</big> — Деление
<big>'''**'''</big> — Возведение в степень
<source lang="bash">
# В Bash, начиная с версии 2.02, был введен оператор возведения в степень -- "**".
let "z=5**3"
echo "z = $z" # z = 125
</source>
<big>'''%'''</big> — модуль (деление по модулю), возвращает остаток от деления
<source lang="bash">
bash$ echo `expr 5 % 3`
2
</source>
Этот оператор может применяться в алгоритмах генерации псевдослучайных чисел в заданном диапазоне, для форматирования вывода на экран и даже для генерации простых чисел. На удивление часто операцию деления по модулю можно встретить в различных численных алгоритмах.
 '''Пример''': '''''Наибольший общий делитель.'''''
<source lang="bash">
#!/bin/bash
# gcd.sh: поиск наибольшего общего делителя
# по алгоритму Эвклида
# Под "наибольшим общим делителем" (нод) двух целых чисел
# понимается наибольшее целое число, которое делит оба делимых без остатка.
# Алгоритм Эвклида выполняет последовательное деление.
# В каждом цикле,
# делимое <--- делитель
# делитель <--- остаток
# до тех пор, пока остаток не станет равным нулю (остаток = 0).
# The gcd = dividend, on the final pass.
# Замечательное описание алгоритма Эвклида можно найти
# на сайте Jim Loy, http://www.jimloy.com/number/euclids.htm.
# ------------------------------------------------------
# Проверка входных параметров
ARGS=2E_B
ADARGS=65
if [ $# -ne "$ARGS" ]
then
echo "Порядок использования: `basename $0` первое-число второе-число"
exit $E_BADARGS
fi
# ------------------------------------------------------
gcd ()
{
# Начальное присваивание.
dividend=$1 # В сущности, не имеет значения
divisor=$2 # какой из них больше.
# Почему?
remainder=1 # Если переменные не инициализировать,
# то работа сценария будет прервана по ошибке
# в первом же цикле.
until [ "$remainder" -eq 0 ]
do
let "remainder = $dividend % $divisor"
dividend=$divisor # Повторить цикл с новыми исходными данными
divisor=$remainder
done # алгоритм Эвклида
} # последнее $dividend и есть нод.
gcd $1 $2echo;
echo "НОД чисел $1 и $2 = $dividend"; echo
# Упражнение :
# --------
# Вставьте дополнительную проверку входных аргументов,
# и предусмотрите завершение работы сценария с сообщением об ошибке, если
# входные аргументы не являются целыми числами.
exit 0
</source>
<big>'''+='''</big> — "плюс-равно" (увеличивает значение переменной на заданное число). <source lang="bash">let "var += 5"</source> значение переменной ''var'' будет увеличено на 5.
<big>'''-='''</big> — "минус-равно" (уменьшение значения переменной на заданное число).
<big>'''*='''</big> — "умножить-равно" (умножить значение переменной на заданное число, результат записать в переменную). <source lang="bash">let "var *= 4"</source> значение переменной ''var'' будет увеличено в 4 раза.
<big>'''/='''</big> — "слэш-равно" (уменьшение значения переменной в заданное число раз).
<big>'''%='''</big> — "процент-равно" (найти остаток от деления значения переменной на заданное число, результат записать в переменную).
Арифметические операторы очень часто используются совместно с командами [[expr]] и [[let]].
 '''Пример''': '''''Арифметические операции.'''''
<source lang="bash">
#!/bin/bash
# От 1 до 6 пятью различными способами.
n=1; echo -n "$n "
let "n = $n + 1" # let "n = n + 1" тоже допустимо
echo -n "$n "
: $((n = $n + 1))
# оператор ":" обязателен, поскольку в противном случае, Bash будет
# интерпретировать выражение "$((n = $n + 1))" как команду.
echo -n "$n "
n=$(($n + 1))
echo -n "$n "
: $[ n = $n + 1 ]
# оператор ":" обязателен, поскольку в противном случае, Bash будет
# интерпретировать выражение "$[ n = $n + 1 ]" как команду.
# Не вызывает ошибки даже если "n" содержит строку.
echo -n "$n "
n=$[ $n + 1 ]
# Не вызывает ошибки даже если "n" содержит строку.
# Старайтесь избегать употребления такой конструкции,
# поскольку она уже давно устарела и не переносима.
echo -n "$n "; echo
# Спасибо Stephane Chazelas.
exit 0
</source>
Целые числа в Bash фактически являются ''длинными целыми'' ('''32-бит''') со знаком, с диапазоном изменений от ''-2147483648'' до ''2147483647''. Если в результате какой либо операции эти пределы будут превышены, то результат получится ошибочным.
<source lang="bash">
#НЕАКТУАЛЕН для версии Bash 4.2!
a=2147483646
echo "a = $a" # a = 2147483646
let "a+=1" # Увеличить "a" на 1.
echo "a = $a" # a = 2147483647
let "a+=1" # увеличить "a" ещё раз, с выходом за границы диапазона.
echo "a = $a" # a = -2147483648
# ОШИБКА! (выход за границы диапазона)
</source>
'''''Версия Bash 2.05b, поддерживает 64-битные целые числа'''''. Bash ничего не знает о существовании чисел с плавающей запятой. Такие числа, из-за наличия символа десятичной точки, он воспринимает как строки.
<source lang="bash">
a=1.5
let "b = $a + 1.3" # Ошибка.
# -bash: let: b = 1.5 + 1.3: syntax error: invalid arithmetic operator (error token is ".5 + 1.3")
echo "b = $b" # b=1
b=
</source>
Для работы с числами с плавающей запятой в сценариях можно использовать утилиту-калькулятор [[bc]].
* <big>'''Битовые операции'''</big>
Битовые операции очень редко используются в сценариях командного интерпретатора. Их главное назначение, на мой взгляд, установка и проверка некоторых значений,читаемых из портов ввода-вывода и сокетов. "Битовые операции" гораздо более уместны в компилирующих языках программирования, таких как C и C++. 
<big>'''<<'''</big> — сдвигает на 1 бит влево (умножение на 2) 
<big>'''<<='''</big> — "сдвиг-влево-равно". <source lang="bash">let "var <<= 2"</source> значение переменной ''var'' сдвигается влево на ''2 бита'' (умножается на 4). 
<big>'''>>'''</big> — сдвиг вправо на 1 бит (деление на 2) 
<big>'''>>='''</big> — "сдвиг-вправо-равно" (имеет смысл обратный <<=) 
<big>'''&'''</big> — по-битовое И (AND) 
<big>'''&='''</big> — по-битовое И-равно 
<big>'''|'''</big> — по-битовое ИЛИ (OR) 
<big>'''|='''</big> — по-битовое ИЛИ-равно 
<big>'''~'''</big> — по-битовая инверсия 
<big>'''!'''</big> — по-битовое отрицание 
<big>'''^'''</big> — по-битовое ИСКЛЮЧАЮЩЕЕ ИЛИ (XOR) 
<big>'''^='''</big> — по-битовое ИСКЛЮЧАЮЩЕЕ-ИЛИ-равно 
* <big>'''Логические операции'''</big> 
<big>'''&&'''</big> — логическое И (and) 
<source lang="bash">
if [ $condition1 ] && [ $condition2 ]
# То же самое, что: if [ $condition1 -a $condition2 ]
# Возвращает true, если оба операнда condition1 и condition2 истинны...\
if [[ $condition1 && $condition2 ]] # То же верно
# Обратите внимание: оператор && не должен использоваться внутри [ ... ]!
</source>
Оператор <big>'''&&'''</big>, в зависимости от контекста, может так же использоваться в "И"-списках для построения составных команд. 
<big>'''||'''</big> — логическое ИЛИ (or) 
<source lang="bash">
if [ $condition1 ] || [ $condition2 ]
# То же самое, что: if [ $condition1 -o $condition2 ]
# Возвращает true, если хотя бы один из операндов истинен...
if [[ $condition1 || $condition2 ]] # Also works.
# Обратите внимание: оператор || не должен использоваться внутри [ ... ].
</source>
Bash производит проверку кода возврата КАЖДОГО из операндов в логических выражениях.
 '''Пример''': '''''Построение сложных условий, использующих && и ||.'''''
<source lang="bash">
#!/bin/bash
a=24
b=47
if [ "$a" -eq 24 ] && [ "$b" -eq 47 ]
then
echo "Первая проверка прошла успешно."
else
echo "Первая проверка не прошла."
fi
# ОКА: if [ "$a" -eq 24 && "$b" -eq 47 ]
# пытается выполнить ' [ "$a" -eq 24 '
# и терпит неудачу наткнувшись на ']'.
# if [[ $a -eq 24 && $b -eq 24 ]] это правильный вариант
# (в строке 17 оператор "&&" имеет иной смысл, нежели в строке 6.)
# Спасибо Stephane Chazelas.
if [ "$a" -eq 98 ] || [ "$b" -eq 47 ]
then
echo "Вторая проверка прошла успешно."
else
echo "Вторая проверка не прошла."
fi
# Опции -a и -o предоставляют
# альтернативный механизм проверки условий.
# Спасибо Patrick Callahan.
if [ "$a" -eq 24 -a "$b" -eq 47 ]
then
echo "Третья проверка прошла успешно."
else
echo "Третья проверка не прошла."
fi
if [ "$a" -eq 98 -o "$b" -eq 47 ]
then
echo "Четвертая проверка прошла успешно."
else
echo "Четвертая проверка не прошла."
fi
a=rhino
b=crocodile
if [ "$a" = rhino ] && [ "$b" = crocodile ]
then
echo "Пятая проверка прошла успешно."
else
echo "Пятая проверка не прошла."
fi
exit 0
</source>
Операторы <big>&&</big> и <big>||</big> могут использоваться и в арифметических вычислениях.
<source lang="bash">
bash$ echo $(( 1 && 2 )) $((3 && 0)) $((4 || 0)) $((0 || 0))
1 0 1 0
</source>
* <big>'''Прочие операции'''</big> 
<big>''','''</big> — запятая 
С помощью оператора запятая можно связать несколько арифметических в одну последовательность. При разборе таких последовательностей, командный интерпретатор вычисляет все выражения (которые могут иметь побочные эффекты) в последовательности и возвращает результат последнего.
<source lang="bash">
let "t1 = ((5 + 3, 7 - 1, 15 - 4))"
echo "t1 = $t1" # t1 = 11
let "t2 = ((a = 9, 15 / 3))" # Выполняется присваивание "a" = 9,
# а затем вычисляется "t2".
echo "t2 = $t2 a = $a" # t2 = 5 a = 9
</source>
Оператор запятая чаще всего находит применение в циклах ''for''.

=== Числовые константы ===
Интерпретатор командной оболочки воспринимает числа как десятичные, в противном случае числу должен предшествовать специальный префикс, либо число должно быть записано в особой нотации. Числа, начинающиеся с символа 0, считаются восьмеричными. если числу предшествует префикс 0x, то число считается шестнадцатеричным. Число, в записи которого присутствует символ #, расценивается как запись числа с указанием основы счисления в виде ''ОСНОВА#ЧИСЛО''.
 '''Пример''': '''''Различные представления числовых констант.'''''
<source lang="bash">
#!/bin/bash
# numbers.sh: Различные представления числовых констант.
# Десятичное: по-умолчанию
let "dec = 32"
echo "десятичное число = $dec" # 32
# В общем-то ничего необычного.
# Восьмеричное: числа начинаются с '0' (нуля)
let "oct = 032"
echo "восьмеричное число = $oct" # 26
# Результат печатается в десятичном виде.
# --------- ------ -- -------
# Шестнадцатиричное: числа начинаются с '0x' или '0X'
let "hex = 0x32"
echo "шестнадцатиричное число = $hex" # 50
# Результат печатается в десятичном виде.
# Другие основы счисления: ОСНОВА#ЧИСЛО
# ОСНОВА должна быть между 2 и 64.
# для записи ЧИСЛА должен использоваться соответствующий ОСНОВЕ диапазон символов,
# см. ниже.
let "bin = 2#111100111001101"
echo "двоичное число = $bin" # 31181
let "b32 = 32#77"
echo "32-ричное число = $b32" # 231
let "b64 = 64#@_"
echo "64-ричное число = $b64" # 4094
#
# Нотация ОСНОВА#ЧИСЛО может использоваться на ограниченном
# диапазоне основ счисления (от 2 до 64)
# 10 цифр + 26 символов в нижнем регистре + 26 символов в верхнем регистре + @ + _
echo
echo $((36#zz)) $((2#10101010)) $((16#AF16)) $((53#1aA))
# 1295 170 44822 3375
# Важное замечание:
# --------------
# Использование символов, для записи числа, выходящих за диапазон,
# соответствующий ОСНОВЕ счисления
# будет приводить к появлению сообщений об ошибках.
let "bad_oct = 081"
# numbers.sh: let: oct = 081: value too great for base (error token is "081")
# Для записи восьмеричных чисел допускается использовать
#+ только цифры в диапазоне 0 - 7.
exit 0 # Спасибо Rich Bartell и Stephane Chazelas, за разъяснения.
</source>

= Часть третья. Углублённый материал =
== К вопросу о переменных ==
Правильное использование переменных может придать сценариям дополнительную мощь и гибкость, а для этого необходимо изучить все тонкости и нюансы.
=== Внутренние переменные ===
* ''Встроенные переменные''
'''''$BASH''''' — путь к исполняемому файлу Bash
<source lang="bash">
bash$ echo $BASH
/bin/bash
</source>
'''''$BASH_VERSINFO[n]''''' — это массив, состоящий из 6 элементов, и содержащий информацию о версии Bash. Очень похожа на переменную ''$BASH_VERSION'', описываемую ниже.
<source lang="bash">
#!/bin/bash
# Информация о версии Bash:
for n in 0 1 2 3 4 5
do
echo "BASH_VERSINFO[$n] = ${BASH_VERSINFO[$n]}"
done
# BASH_VERSINFO[0] = 2 # Major version no.
# BASH_VERSINFO[1] = 05 # Minor version no.
# BASH_VERSINFO[2] = 8 # Patch level.
# BASH_VERSINFO[3] = 1 # Build version.
# BASH_VERSINFO[4] = release # Release status.
# BASH_VERSINFO[5] = i386-redhat-linux-gnu # Architecture
# (same as $MACHTYPE).
</source>
'''''$BASH_VERSINFO''''' — версия Bash, установленного в системе
<source lang="bash">
bash$ echo $BASH_VERSION
2.04.12(1)-release

tcsh% echo $BASH_VERSION
BASH_VERSION: Undefined variable.
</source>
Проверка переменной ''$BASH_VERSION'' — неплохой метод проверки типа командной оболочки, под которой исполняется скрипт. Переменная ''$SHELL'' не всегда даёт правильный ответ. 
'''''$DIRSTACK''''' — содержимое вершины стека каталогов (который управляется командами pushd и popd)
Эта переменная соответствует команде [[dirs]], за исключением того, что [[dirs]] показывает полное содержимое всего стека каталогов. 
'''''$EDITOR''''' — заданный по-умолчанию редактор, вызываемый скриптом, обычно '''vi''' или '''emacs''' 
'''''$EUID''''' — "эффективный" идентификационный номер пользователя (Effective User ID)
Идентификационный номер пользователя, права которого были получены, возможно с помощью команды [[su]]. Значение переменной ''$EUID'' необязательно должно совпадать с содержимым переменной ''$UID''. 
'''''$FUNCNAME''''' — имя текущей функции
<source lang="bash">
xyz23 ()
{
echo "Исполняется функция $FUNCNAME." # Исполняется функция xyz23.
}
xyz23
echo "FUNCNAME = $FUNCNAME" # FUNCNAME =
# Пустое (Null) значение за пределами функций.
</source>
'''''$GLOBIGNORE''''' — Перечень шаблонных символов, которые будут проигнорированы при выполнении подстановки имён файлов (globbing) 
'''''$GROUPS''''' — группы, к которым принадлежит текущий пользователь
Это список групп (массив) идентификационных номеров групп для текущего пользователя, какэо записано в /etc/passwd.
<source lang="bash">
root# echo $GROUPS
0
root# echo ${GROUPS[1]}
1
root# echo ${GROUPS[5]}
6
</source>
'''''$HOME''''' — домашний каталог пользователя, как правило это /home/username 
'''''$HOSTNAME''''' — Сетевое имя хоста устанавливается командой hostname во время исполнения инициализирующих сценариев при загрузке системы. Внутренняя переменная ''$HOSTNAME'' Bash получает своё значение посредством вызова функции gethostname(). 
'''''$HOSTTYPE''''' — тип машины
Подобно ''$MACHTYPE'', идентифицирует аппаратную архитектуру.
<source lang="bash">
bash$ echo $HOSTTYPE
i686
</source>
'''''$IFS''''' — разделитель полей во вводимой строке (IFS — Internal Field Separator)
Эта переменная управляет порядком выделения полей (задаёт символы-разделители) приразборе строки символов. По-умолчанию — пробельный символ (пробел, табуляция и перевод строки), но может быть изменён, например, для разбора строк, в которых отдельные поля разделены запятыми. Обратите внимание: при составлении содержимого переменной ''$*'', Bash использует первый символ из ''$IFS'' для разделения аргументов.
<source lang="bash">
bash$ echo $IFS | cat -vte
$
bash$ bash -c 'set w x y z; IFS=":-;"; echo "$*"'
w:x:y:z
</source>
При всём при том следует помнить, что при использовании ''$IFS'' пробельные символы обрабатываются несколько иначе, чем все остальные.
 '''Пример''': '''''$IFS и пробельные символы.'''''
<source lang="bash">
#!/bin/bash
# При использовании $IFS, пробельные символы обрабатываются иначе, чем все остальные.
output_args_one_per_line()
{
for arg
do echo "[$arg]"
done
}
echo; echo "IFS=\" \""
echo "-------"
IFS=" "
var=" a b c "
output_args_one_per_line $var # output_args_one_per_line `echo " a b c "`
# [a]
# [b]
# [c]
echo; echo "IFS=:"
echo "-----"
IFS=:
var=":a::b:c:::" # То же самое, только пробелы заменены символом ":".
output_args_one_per_line $var
#
# []
# [a]
# []
# [b]
# [c]
# []
# []
# []
# То же самое происходит и с разделителем полей "FS" в awk.
# Спасибо Stephane Chazelas.
echo
exit 0
#(Спасибо S. C., за разъяснения и примеры.)
</source>
'''''$LC_COLLATE''''' — Чаще всего устанавливается в ''.bashrc'' или ''/etc/profile', эта переменная задаёт порядок сортировки символов, в операциях подстановки имён файлов и в поиске по шаблону. При неверной настройке переменной ''LC_COLLATE'' можно получить весьма неожиданные результаты. Начиная с версии 2.05, Bash, в операциях подстановки имён файлов, не делает различий между символами верхнего и нижнего регистров, в диапазонах символов в квадратных скобках. Например, ''ls [A-M]*'' выведет как File1.txt, так и file1.txt. Возврат к общепринятому стандарту поведения шаблонов вквадратных скобках выполняется установкой переменной ''LC_COLLATE'' в значение ''C'' командой ''export LC_COLLATE=C'' в файле ''/etc/profile'' и/или ''~/.bashrc''. 
'''''$LC_CTYPE''''' — Эта внутренняя переменная определяет кодировку символов. Используется в операциях подстановки и поиске по шаблону. 
'''''$LINENO''''' — Номер строки исполняемого сценария. Эта переменная имеет смысл только внутри исполняемого сценария и чаще всего применяется в отладочных целях.
<source lang="bash">
# *** BEGIN DEBUG BLOCK ***
last_cmd_arg=$_ # Запомнить.
echo "Строка $LINENO: переменная \"v1\" = $v1"
echo "Последний аргумент командной строки = $last_cmd_arg"
# *** END DEBUG BLOCK ***
</source>
'''''$MACHTYPE''''' — аппаратная архитектура. Идентификатор аппаратной архитектуры.
<source lang="bash">
bash$ echo $MACHTYPE
i686
</source>
'''''$OLDPWD''''' — прежний рабочий каталог ("OLD-Print-Working-Directory")
'''''$OSTYPE''''' — тип операционной системы
<source lang="bash">
bash$ echo $OSTYPE
linux
</source>
'''''$PATH''''' — путь поиска, как правило включает в себя каталоги ''/usr/bin/'', ''/usr/X11R6/bin/'', ''/usr/local/bin'',и т.д.
Когда командный интерпретатор получает команду, то он автоматически пытается отыскать соответствующий исполняемый файл в указанном списке каталогов (в переменной ''$PATH''). Каталоги, в указанном списке, должны отделяться друг от друга двоеточиями. Обычно,переменная ''$PATH'' инициализируется в ''/etc/profile'' и/или в ''~/.bashrc''.
<source lang="bash">
bash$ echo $PATH
/bin:/usr/bin:/usr/local/bin:/usr/X11R6/bin:/sbin:/usr/sbin
</source>
Инструкция ''PATH=${PATH}:/opt/bin'' добавляет каталог ''/opt/bin'' в конец текущего пути поиска.
Иногда может оказаться целесообразным, внутри сценария, временно добавить какой-либо каталог к пути поиска. По завершении работы скрипта, эти изменения будут утеряны(вспомните о том, что невозможно изменить переменные окружения вызывающего процесса). Текущий "рабочий каталог", ./, обычно не включается в $PATH из соображений безопасности. 
'''''$PIPESTATUS''''' — Код возврата канала (конвейера). Интересно, что это не то же самое, что код возврата последней исполненной команды.
<source lang="bash">
bash$ echo $PIPESTATUS
0
bash$ ls -al | bogus_command
bash: bogus_command: command not found
bash$ echo $PIPESTATUS
141
bash$ ls -al | bogus_command
bash: bogus_command: command not found
bash$ echo $?
127
</source>
Переменная ''$PIPESTATUS'' может давать неверные значения при вызове из командной строки.
<source lang="bash">
tcsh% bash
bash$ who | grep nobody | sort
bash$ echo ${PIPESTATUS[*]}
0
</source>
Если поместить эти строки в сценарий и исполнить его, то будут выведены верные значения 0 1 0. Спасибо Wayne Pollock за замечания и предоставленный пример. 
'''''$PPID''''' — Переменная ''$PPID'' хранит PID (идентификатор) родительского процесса. Сравните с командой [[pidof]]. 
'''''$PROMPT_COMMAND''''' — Переменная хранит команду, которая используется непосредственно для вывода первичного приглашения к вводу — ''$PS1''. 
'''''$PS1''''' — prompt, приглашение командной строки. 
'''''$PS2''''' — Вторичное приглашение командной строки, выводится тогда, когда от пользователя ожидается дополнительный ввод. Отображается как ">". 
'''''$PS3''''' — Третичное приглашение (prompt), выводится тогда, когда пользователь должен сделать выбор в операторе ''select''. 
'''''$PS4''''' — Приглашение (prompt) четвёртого уровня, выводится в начале каждой строки вывода тогда, когда сценарий вызывается с ключом ''-x''. Отображается как "+". 
'''''$PWD''''' — рабочий (текущий) каталог
 '''Пример''': '''''Аналог встроенной команды pwd.'''''
<source lang="bash">
#!/bin/bash
E_WRONG_DIRECTORY=73
clear # Очистка экрана.
TargetDirectory=/home/bozo/projects/GreatAmericanNovel
cd $TargetDirectory
echo "Удаление файлов в каталоге $TargetDirectory."
if [ "$PWD" != "$TargetDirectory" ]
then # Защита от случайного удаления файлов не в том каталоге.
echo "Неверный каталог!"
echo "Переменная $PWD указывает на другой каталог!"
exit $E_WRONG_DIRECTORY
fi
rm -rf *
rm .[A-Za-z0-9]* # удалить "скрытые" файлы (начинающиеся с ".")
# rm -f .[^.]* ..?* удалить файлы, чьи имена начинаются с нескольких точек.
# (shopt -s dotglob; rm -f *) тоже работает верно.
# Спасибо S.C. за замечание.
# Имена файлов могут содержать любые символы из диапазона 0-255, за исключением "/".
# Оставляю вопрос удаления файлов с "необычными" символами для самостоятельного изучения.
# Здесь можно вставить дополнительные действия, по мере необходимости.
echo
echo "Конец."
echo "Файлы, из каталога $TargetDirectory, удалены."
echo
exit 0
</source>
'''''$REPLY''''' — переменная по-умолчанию, куда записывается ввод пользователя, выполненный с помощью команды ''read'', если явно не задана другая переменная. Так же может использоваться в операторе ''select'', для построения меню выбора.
<source lang="bash">
#!/bin/bash
echo
echo -n "Ваше любимое растение? "
read
echo "Ваше любимое растение: $REPLY."
# REPLY хранит последнее значение, прочитанное командой "read" тогда, и только тогда
# когда команде "read" не передается имя переменной.
echo
echo -n "Ваш любимый фрукт? "
read fruit
echo "Ваш любимый фрукт $fruit."
echo "но..."
echo "Значение переменной \$REPLY осталось равным $REPLY."
# Переменная $REPLY не была перезаписана потому, что
# следующей команде "read", в качестве аргумента была передана переменная $fruit
echo
exit 0
</source>
'''''$SECONDS''''' — Время паботы сценария в секундах
<source lang="bash">
#!/bin/bash
# Автор: Mendel Cooper
# Дополнен переводчиком.
TIME_LIMIT=10
INTERVAL=1
echo
echo "Для прерывания работы сценария, ранее чем через $TIME_LIMIT секунд, нажмите Control-C."
echo
while [ "$SECONDS" -le "$TIME_LIMIT" ]
do
# Оригинальный вариант сценария содержал следующие строки
# if [ "$SECONDS" -eq 1 ]
# then
# units=second
# else
# units=seconds
# fi
# Однако, из-за того, что в русском языке для описания множественного числа
# существует большее число вариантов, чем в английском,
# переводчик позволил себе смелость несколько подправить сценарий
# (прошу ногами не бить! ;-) )
# === НАЧАЛО БЛОКА ИЗМЕНЕНИЙ, ВНЕСЕННЫХ ПЕРЕВОДЧИКОМ ===
let "last_two_sym = $SECONDS - $SECONDS / 100 * 100" # десятки и единицы
if [ "$last_two_sym" -ge 11 -a "$last_two_sym" -le 19 ]
then
units="секунд" # для чисел, которые заканчиваются на "...надцать"
else
let "last_sym = $last_two_sym - $last_two_sym / 10 * 10" # единицы
case "$last_sym" in
"1" )
units="секунду" # для чисел, заканчивающихся на 1
;;
"2" | "3" | "4" )
units="секунды" # для чисел, заканчивающихся на 2, 3 и 4
;;
* )
units="секунд" # для всех остальных (0, 5, 6, 7, 8, 9)
;;
esac
fi
# === КОНЕЦ БЛОКА ИЗМЕНЕНИЙ, ВНЕСЕННЫХ ПЕРЕВОДЧИКОМ ===
echo "Сценарий отработал $SECONDS $units."
# В случае перегруженности системы, скрипт может перескакивать через отдельные
# значения счетчика
sleep $INTERVAL
done
echo -e "\a" # Сигнал!
exit 0
</source>
'''''$SHELLOPTS''''' — список допустимых опций интерпретатора ''shell''. Переменная доступна только для чтения.
<source lang="bash">
bash$ echo $SHELLOPTS
braceexpand:hashall:histexpand:monitor:history:interactive-comments:emacs
</source>
'''''$SHLVL''''' — Уровень вложенности ''shell''. Если в командной строке ''echo $SHLVL'' даёт 1, то в сценарии значение этой переменной будет больше на 1, т.е. 2. 
'''''$TMOUT''''' — Если переменная окружения ''$TMOUT'' содержит ненулевое значение, то интерпретатор будет ожидать ввод не более чем заданное число секунд, что, в первичном приглашении (см.описание PS1 выше), может привести к автоматическому завершению сеанса работы. Начиная с версии 2.05b Bash, стало возможным использование $TMOUT в сценариях в комбинации с ''read''.
<source lang="bash">
# Работает только в сценариях Bash, начиная с версии 2.05b.
TMOUT=3 # Ожидание ввода не более трех секунд.
echo "Ваша любимая песня?"
echo "Вводите быстрее, у Вас только $TMOUT секунды на обдумывание!"
read song
if [ -z "$song" ]
then
song="(ответ не получен)"
# По-умолчанию.
fi
echo "Вам нравится $song."
</source>
Возможны и более сложные варианты организации организации ограничения времени ожидания ввода. Как один из вариантов, можно предложить организовать прерывание цикла ожидания по сигналу. Но это потребует написание функции обработки сигналов командой ''trap''.
 '''Пример''': '''''Ограничения времени ожидания ввода.'''''
<source lang="bash">
#!/bin/bash
# timed-input.sh
# TMOUT=3 бесполезно в сценариях
TIMELIMIT=3 # Три секунды в данном случае, но может быть установлено и другое значение
PrintAnswer()
{
if [ "$answer" = TIMEOUT ]
then
echo $answer
else # Чтобы не спутать разные варианты вывода.
echo "Ваше любимое растение $answer"
kill $! # "Прибить" ненужную больше функцию TimerOn, запущенную в фоновом процессе.
# $! — PID последнего процесса, запущенного в фоне.
fi
}
TimerOn()
{
sleep $TIMELIMIT && kill -s 14 $$ &
# Ждать 3 секунды, после чего выдать sigalarm сценарию.
}
Int14Vector()
{
answer="TIMEOUT"
PrintAnswer
exit 14
}
trap Int14Vector 14 # переназначить процедуру обработки прерывания от таймера (14)
echo "Ваше любимое растение? "
TimerOn
read answer
PrintAnswer# По общему признанию, это не очень хороший способ ограничения времени ожидания,
# По общему признанию, это не очень хороший способ ограничения времени ожидания,
# однако опция "-t" команды "read" упрощает задачу.
# См. "t-out.sh", ниже.
# Если вам нужно что-то более элегантное...
# подумайте о написании программы на C или C++,
# с использованием соответствующих библиотечных функций, таких как 'alarm' и 'setitimer'.
exit 0
</source>
В качестве альтернативы можно использовать stty.
 '''Пример''': '''''Ещё один пример ограничения времени ожидания ввода от пользователя'''''
<source lang="bash">
#!/bin/bash
#timeout.sh
# Автор: Stephane Chazelas,
# дополнен автором документа.
INTERVAL=5 # предел времени ожидания
timedout_read()
{
timeout=$1
varname=$2
old_tty_settings=`stty -g`
stty -icanon min 0 time ${timeout}0
eval read $varname # или просто read $varname
stty "$old_tty_settings"
# См. man stty.
}
echo; echo -n "Как Вас зовут? Отвечайте быстрее! "
timedout_read $INTERVAL your_name
# Такой прием может не работать на некоторых типах терминалов.
# Максимальное время ожидания зависит от терминала.
# (чаще всего это 25.5 секунд).
echo
if [ ! -z "$your_name" ] # Если имя было введено...
then
echo "Вас зовут $your_name."
else
echo "Вы не успели ответить."
fi
echo
# Алгоритм работы этого сценария отличается от "timed-input.sh".
# Каждое нажатие на клавишу вызывает сброс счетчика в начальное состояние.
exit 0
</source>
Возможно самый простой способ — использовать опцию -t команды ''read''.
 '''Пример''': '''''Ограничение времени ожидания команды read'''''
<source lang="bash">
#!/bin/bash
# t-out.sh
TIMELIMIT=4 # 4 секунды
read -t $TIMELIMIT variable <&1
echo
if [ -z "$variable" ]
then
echo "Время ожидания истекло."
else
echo "variable = $variable"
fi
exit 0
</source>
'''''$UID''''' — user id number, UID (идентификатор) текущего пользователя, в соответствии с /etc/passwd
Это реальный UID текущего пользователя, даже если он временно приобрёл права другого пользователя с помощью su. Переменная $UID доступна только для чтения.
 '''Пример''': '''''Я — root?'''''
<source lang="bash">
#!/bin/bash
# am-i-root.sh: Root я, или не root?
ROOT_UID=0 # $UID root-а всегда равен 0.
if [ "$UID" -eq "$ROOT_UID" ] # Настоящий "root"?
then
echo "- root!"
else
echo "простой пользователь (но мамочка вас тоже любит)!"
fi
exit 0
# ============================================================= #
# Код, приведённый ниже, никогда не отработает,
# поскольку работа сценария уже завершилась выше
# Еще один способ отличить root-а от не root-а:
ROOTUSER_NAME=root
username=`id -nu` # Или... username=`whoami`
if [ "$username" = "$ROOTUSER_NAME" ]
then
echo "Рутти-тутти. - root!"
else
echo "Вы - лишь обычный юзер."
fi
</source>
Переменные ''$ENV'', ''$LOGNAME'', ''$MAIL'', ''$TERM'', ''$USER'' и ''$USERNAME'', не являются встроенными переменными Bash. Тем не менее, они часто инициализируются как переменные окружения в одном из стартовых файлов Bash. Переменная ''$SHELL'', командная оболочка пользователя, может задаваться в ''/etc/passwd'' или в сценарии "init" и она тоже не является встроенной переменной Bash!
<source lang="bash">
tcsh% echo $LOGNAME
bozo
tcsh% echo $SHELL
/bin/tcsh
tcsh% echo $TERM
rxvt
bash$ echo $LOGNAME
bozo
bash$ echo $SHELL
/bin/tcsh
bash$ echo $TERM
rxvt
</source>
* ''Позиционные параметры (аргументы)''
'''''$0''''', '''''$1''''', '''''$2''''' и т.д. — аргументы передаются... из командной строки в сценарий, функциям или команде set 
'''''$#''''' — Количество аргументов командной строки, или позиционных параметров 
'''''$*''''' — Все аргументы (позиционные параметры), в виде одной строки (слова)
"$*" — необходимо заключать в кавычки. 
'''''$@''''' — То же самое, что и "$*", но при этом каждый параметр представлен как отдельная строка(слово), т.е. параметры не подвергаются какой-либо интерпретации.
"$@" -- необходимо заключать в кавычки. 
 '''Пример''': '''''Я — root?'''''
<source lang="bash">
#!/bin/bash
# Вызовите сценарий с несколькими аргументами, например: "один два три".
E_BADARGS=65
if [ ! -n "$1" ]
then
echo "Порядок использования: `basename $0` argument1 argument2 и т.д."
exit $E_BADARGS
fi
echo
index=1
echo "Список аргументов в переменной \"\$*\":"
for arg in "$*" # Работает некорректно, если "$*" не ограничена кавычками.
do
echo "Аргумент #$index = $arg"
let "index+=1"
done # $* воспринимает все аргументы как одну строку.
echo "Полный список аргументов выглядит как одна строка."
echo
index=1
echo "Список аргументов в переменной \"\$@\":"
for arg in "$@"
do
echo "Аргумент #$index = $arg"
let "index+=1"
done # $@ воспринимает аргументы как отдельные строки (слова).
echo "Список аргументов выглядит как набор различных строк (слов)."
echo
exit 0
</source>
После команды ''shift'' (сдвиг), первый аргумент, в переменной "$@", теряется, а остальные сдвигаются на одну позицию "вниз" (или "влево", если хотите).
<source lang="bash">
#!/bin/bash
# Вызовите сценарий в таком виде: ./scriptname 1 2 3 4 5
echo "$@" # 1 2 3 4 5
shift
echo "$@" # 2 3 4 5
shift
echo "$@" # 3 4 5
# Каждая из команд "shift" приводит к потере аргумента $1,
# но остальные аргументы остаются в "$@".
</source>
Специальная переменная $@ может быть использована для выбора типа ввода в сценария. Команда cat "$@" позволяет выполнять ввод как со стандартного устройства ввода ''stdin'', так ииз файла, имя которого передаётся сценарию из командной строки. Переменные '''''$*''''' и '''''$@''''', в отдельных случаях, могут содержать противоречивую информацию! Это зависит от содержимого переменной '''''$IFS'''''.
 '''Пример''': '''''Противоречия в переменных $* и $@'''''
<source lang="bash">
#!/bin/bash
# Демонстрация противоречивости содержимого внутренних переменных "$*" и "$@",
# которая проявляется при изменении порядка заключения параметров в кавычки.
# Демонстрация противоречивости, проявляющейся при изменении
# содержимого переменной IFS.
set -- "Первый один" "второй" "третий:один" "" "Пятый: :один"
# Установка аргументов $1, $2, и т.д.
echo
echo 'IFS по-умолчанию, переменная "$*"'
c=0
for i in "$*" # в кавычках
do echo "$((c+=1)): [$i]" # Эта строка остается без изменений во всех циклах.
# Вывод аргументов.
done
echo ---
echo 'IFS по-умолчанию, переменная $*'
c=0
for i in $* # без кавычек
do echo "$((c+=1)): [$i]"
done
echo ---
echo 'IFS по-умолчанию, переменная "$@"'
c=0
for i in "$@"
do echo "$((c+=1)): [$i]"
done
echo ---
echo 'IFS по-умолчанию, переменная $@'
c=0
for i in $@
do echo "$((c+=1)): [$i]"
done
echo ---
IFS=:
echo 'IFS=":", переменная "$*"'
c=0
for i in "$*"
do echo "$((c+=1)): [$i]"
done
echo ---
echo 'IFS=":", переменная $*'
c=0
for i in $*
do echo "$((c+=1)): [$i]"
done
echo ---
var=$*
echo 'IFS=":", переменная "$var" (var=$*)'
c=0
for i in "$var"
do echo "$((c+=1)): [$i]"
done
echo ---
echo 'IFS=":", переменная $var (var=$*)'
c=0
for i in $var
do echo "$((c+=1)): [$i]"
done
echo ---
var="$*"
echo 'IFS=":", переменная $var (var="$*")'
c=0
for i in $var
do echo "$((c+=1)): [$i]"
done
echo ---
echo 'IFS=":", переменная "$var" (var="$*")'
c=0
for i in "$var"
do echo "$((c+=1)): [$i]"
done
echo ---
echo 'IFS=":", переменная "$@"'
c=0
for i in "$@"
do echo "$((c+=1)): [$i]"
done
echo ---
echo 'IFS=":", переменная $@'
c=0
for i in $@
do echo "$((c+=1)): [$i]"
done
echo ---
var=$@
echo 'IFS=":", переменная $var (var=$@)'
c=0
for i in $var
do echo "$((c+=1)): [$i]"
done
echo ---
echo 'IFS=":", переменная "$var" (var=$@)'
c=0
for i in "$var"
do echo "$((c+=1)): [$i]"
done
echo ---
var="$@"
echo 'IFS=":", переменная "$var" (var="$@")'
c=0
for i in "$var"
do echo "$((c+=1)): [$i]"
done
echo ---
echo 'IFS=":", переменная $var (var="$@")'
c=0
for i in $var
do echo "$((c+=1)): [$i]"
done
echo# Попробуйте запустить этот сценарий под ksh или zsh -y.
exit 0
# Это сценарий написан Stephane Chazelas,
# Незначительные изменения внесены автором документа.
</source>
'''''Различия между $@ и $* наблюдаются только тогда, когда они помещаются в двойные кавычки!'''''
 '''Пример''': '''''Содержимое $* и $@, когда переменная $IFS — пуста'''''
<source lang="bash">
#!/bin/bash
# Если переменная $IFS инициализирована "пустым" значением,
# то "$*" и "$@" содержат аргументы не в том виде, в каком ожидается.
mecho () # Вывод аргументов.
{
echo "$1,$2,$3";
}
IFS="" # Инициализация "пустым" значением.
set a b c # Установка аргументов.
mecho "$*" # abc,,
mecho $* # a,b,c
mecho $@ # a,b,c
mecho "$@" # a,b,c
# Поведение переменных $* и $@, при "пустой" $IFS, зависит
# от версии командной оболочки, Bash или sh.
# Поэтому, было бы неразумным пользоваться этой "фичей" в своих сценариях.
# Спасибо S.C.
exit 0
</source>
* ''Прочие специальные переменные''
'''''$-''''' — Список флагов, переданных сценарию (командой ''set'')
Эта конструкция изначально была введена в ksh, откуда перекочевала в Bash и, похоже, работает в Bash не совсем надежно. Единственное возможное применение — проверка запущен ли сценарий в интерактивном режиме. 
'''''$!''''' — PID последнего, запущенного в фоне, процесса
<source lang="bash">
LOG=$0.log
COMMAND1="sleep 100"
echo "Запись в лог всех PID фоновых процессов, запущенных из сценария: $0" >> "$LOG"
# Таким образом возможен мониторинг и удаление процессов по мере необходимости.
echo >> "$LOG"
# Команды записи в лог.
echo -n "PID of \"$COMMAND1\": " >> "$LOG"
${COMMAND1} &
echo $! >> "$LOG"
# PID процесса "sleep 100": 1506
# Спасибо Jacques Lederer за предложенный пример.
</source>
'''''$_''''' — Специальная переменная, содержит последний аргумент предыдущей команды.
 '''Пример''': '''''Переменная "подчеркивание"'''''
<source lang="bash">
#!/bin/bash
echo $_ # /bin/bash
# Для запуска сценария был вызван /bin/bash.
du >/dev/null # Подавление вывода.
echo $_ # du
ls -al >/dev/null # Подавление вывода.
echo $_ # -al (последний аргумент)
:
echo $_ # :
</source>
'''''$?''''' — Код возврата команды, функции или скрипта 
'''''$$''''' — PID самого процесса-сценария. Переменная ''$$'' часто используется при генерации "уникальных" имён для временных файлов. Обычно это проще, чем вызов [[mktemp]].

=== Работа со строками ===
Bash поддерживает на удивление большое количество операций над строками. К сожалению, этот раздел Bash испытывает недостаток унификации. Одни операции являются подмножеством операций подстановки параметров, а другие — совпадают с функциональностью команды Unix — expr. Это приводит к противоречиям в синтаксисе команд и перекрытию функциональных возможностей, не говоря уже о возникающей путанице.

<big>'''Длина строки:'''</big>
<source lang="bash">
${#string}
expr length $string
expr "$string" : '.*'
stringZ=abcABC123ABCabcecho ${#stringZ} # 15
echo `expr length $stringZ` # 15
echo `expr "$stringZ" : '.*'`
</source>
 '''Пример''': '''''Вставка пустых строк между параграфами в текстовом файле.'''''
<source lang="bash">
#!/bin/bash
# paragraph-space.sh
# Вставка пустых строк между параграфами в текстовом файле.
MINLEN=45 # Возможно потребуется изменить это значение.
# Строки, содержащие количество символов меньшее, чем $MINLEN
# принимаются за последнюю строку параграфа.
while read line # Построчное чтение файла от начала до конца...
do
echo "$line" # Вывод строки.
len=${#line}
if [ "$len" -lt "$MINLEN" ]
then echo # Добавление пустой строки после последней строки параграфа.
fi
done
exit 0
</source>
<big>'''Длина подстроки в строке (подсчёт совпадающих символов ведётся с начала строки):'''</big> 
<big>''expr match "$string" '$substring' ''</big>, где $substring — регулярное выражение. 
<big>''expr "$string" : '$substring' ''</big>, где $substring — регулярное выражение. 
<source lang="bash">
stringZ=abcABC123ABCabc
# |------|
echo `expr match "$stringZ" 'abc[A-Z]*.2'` # 8
echo `expr "$stringZ" : 'abc[A-Z]*.2'` # 8
</source>
<big>'''Index:'''</big>
 Номер позиции первого совпадения в ''$string'' c первым символом в ''$substring'': 
<big>''expr index $string $substring''</big> 
<source lang="bash">
stringZ=abcABC123ABCabc
echo `expr index "$stringZ" C12` # 6
# позиция символа C.
echo `expr index "$stringZ" 1c` # 3
# символ 'c' (в #3 позиции) совпал раньше, чем '1'.
</source>
Эта функция довольно близка к функции strchr() в языке C. 
<big>'''Извлечение подстроки:'''</big> 
<big>''${string:position}''</big> 
Извлекает подстроку из ''$string'', начиная с позиции ''$position''. 
Если строка ''$string'' — "<big>'''*'''</big>" или "<big>'''@'''</big>", то извлекается позиционный параметр (аргумент), с номером ''$position''. 
<big>''${string:position:length}''</big> 
Извлекает ''$length'' символов из ''$string'', начиная с позиции ''$position''.
<source lang="bash">
stringZ=abcABC123ABCabc
# 0123456789.....
# Индексация начинается с 0.
echo ${stringZ:0} # abcABC123ABCabc
echo ${stringZ:1} # bcABC123ABCabc
echo ${stringZ:7} # 23ABCabc
echo ${stringZ:7:3} # 23A
# Извлекает 3 символа.
# Возможна ли индексация с "правой" стороны строки?
echo ${stringZ:-4} # abcABC123ABCabc
# По-умолчанию выводится полная строка.
# Однако ...
echo ${stringZ:(-4)} # Cabc
echo ${stringZ: -4} # Cabc
# Теперь выводится правильно.
# Круглые скобки или дополнительный пробел "экранируют" параметр позиции.
# Спасибо Dan Jacobson, за разъяснения.
</source>
Если $string — "<big>'''*'''</big>" или "<big>'''@'''</big>", то извлекается до ''$length'' позиционных параметров (аргументов), начиная с ''$position''.
<source lang="bash">
echo ${*:2} # Вывод 2-го и последующих аргументов.
echo ${@:2} # То же самое.
echo ${*:2:3} # Вывод 3-х аргументов, начиная со 2-го.
</source> 
<big>''expr substr $string $position $length''</big> 
Извлекает ''$length'' символов из ''$string'', начиная с позиции ''$position''.
<source lang="bash">
stringZ=abcABC123ABCabc # 123456789......# Индексация начинается с 1.
echo `expr substr $stringZ 1 2` # ab
echo `expr substr $stringZ 4 3` # ABC
</source> 
<big>''expr match "$string" '$$substring$' ''</big> 
Находит и извлекает первое совпадение ''$substring'' в ''$string'', где ''$substring'' — это регулярное выражение. 
<big>''expr "$string" : '$$substring$' ''</big> 
Находит и извлекает первое совпадение ''$substring'' в ''$string'', где ''$substring'' — это регулярное выражение.
<source lang="bash">
stringZ=abcABC123ABCabc
# =======
echo `expr match "$stringZ" '$.[b-c]*[A-Z]..[0-9]$'` # abcABC1
echo `expr "$stringZ" : '$.[b-c]*[A-Z]..[0-9]$'` # abcABC1
echo `expr "$stringZ" : '$.......$'` # abcABC1
# Все вышеприведённые операции дают один и тот же результат.
</source>
<big>''expr match "$string" '.*$$substring$' ''</big> 
Находит и извлекает первое совпадение ''$substring'' в ''$string'', где ''$substring'' — это регулярное выражение. Поиск начинается с конца ''$string''. 
<big>''expr "$string" : '.*$$substring$' ''</big> 
Находит и извлекает первое совпадение ''$substring'' в ''$string'', где ''$substring'' — это регулярное выражение. Поиск начинается с конца ''$string''. 
<source lang="bash">
stringZ=abcABC123ABCabc# ======
echo `expr match "$stringZ" '.*$[A-C][A-C][A-C][a-c]*$'` # ABCabc
echo `expr "$stringZ" : '.*$......$'` # ABCabc
</source>
<big>'''Удаление части строки:'''</big> 
<big>''${string#substring}''</big> 
Удаление самой короткой, из найденных, подстроки ''$substring'' в строке ''$string''. Поиск ведётся с начала строки. 
<big>''${string##substring}''</big> 
Удаление самой длинной, из найденных, подстроки ''$substring'' в строке ''$string''. Поиск ведётся сначала строки. 
<source lang="bash">
stringZ=abcABC123ABCabc
# |----|
# |----------|
echo ${stringZ#a*C} # 123ABCabc
# Удаление самой короткой подстроки.
echo ${stringZ##a*C} # abc
# Удаление самой длинной подстроки.
</source>
<big>''${string%substring}''</big> 
Удаление самой короткой, из найденных, подстроки ''$substring'' в строке ''$string''. Поиск ведётся с конца строки. 
<big>''${string%%substring}''</big> 
Удаление самой длинной, из найденных, подстроки ''$substring'' в строке ''$string''. Поиск ведётся с конца строки.
<source lang="bash">
stringZ=abcABC123ABCabc
#||
# |------------|
echo ${stringZ%b*c} # abcABC123ABCa
# Удаляется самое короткое совпадение. Поиск ведётся с конца $stringZ.
echo ${stringZ%%b*c} # a
# Удаляется самое длинное совпадение. Поиск ведётся с конца $stringZ.
</source>
 '''Пример''': '''''Преобразование графических файлов из одного формата в другой, с изменением имени файла.'''''
<source lang="bash">
#!/bin/bash
# cvt.sh:
# Преобразование всех файлов в заданном каталоге,
# из графического формата MacPaint, в формат "pbm".
# Используется утилита "macptopbm", входящая в состав пакета "netpbm",
# который сопровождается Brian Henderson (bryanh@giraffe-data.com).
# Netpbm — стандартный пакет для большинства дистрибутивов Linux.
OPERATION=macptopbm
SUFFIX=pbm # Новое расширение файла.
if [ -n "$1" ]
then
directory=$1 # Если каталог задан в командной строке при вызове сценария
else
directory=$PWD # Иначе просматривается текущий каталог.
fi
# Все файлы в каталоге, имеющие расширение ".mac", считаются файлами
# формата MacPaint.
for file in $directory/* # Подстановка имен файлов.
do
filename=${file%.*c} # Удалить расширение ".mac" из имени файла
# ( с шаблоном '.*c' совпадают все подстроки
# начинающиеся с '.' и заканчивающиеся 'c',
$OPERATION $file > "$filename.$SUFFIX"
# Преобразование с перенаправлением в файл с новым именем
rm -f $file # Удаление оригинального файла после преобразования.
echo "$filename.$SUFFIX" # Вывод на stdout.
done
exit 0
# Упражнение:
# --------
# Сейчас этот сценарий конвертирует *все* файлы в каталоге
# Измените его так, чтобы он конвертировал *только* те файлы,
# которые имеют расширение ".mac".
</source>
<big>'''Замена подстроки:'''</big> 
<big>''${string/substring/replacement}''</big> 
Замещает первое вхождение ''$substring'' строкой ''$replacement''. 
<big>''${string//substring/replacement}''</big> 
Замещает все вхождения ''$substring'' строкой ''$replacement''. 
<source lang="bash">
stringZ=abcABC123ABCabc
echo ${stringZ/abc/xyz} # xyzABC123ABCabc
# Замена первой подстроки 'abc' строкой 'xyz'.
echo ${stringZ//abc/xyz} # xyzABC123ABCxyz
# Замена всех подстрок 'abc' строкой 'xyz'.
</source>
<big>''${string/#substring/replacement}''</big> 
Подстановка строки ''$replacement'' вместо ''$substring'', если строка ''$string'' начинается найденным соответствием. Поиск ведётся с начала строки ''$string''. 
<big>''${string/%substring/replacement}''</big> 
Подстановка строки ''$replacement'' вместо ''$substring'', если строка ''$string'' заканчивается найденным соответствием. Поиск ведётся с конца строки ''$string''.
<source lang="bash">
stringZ=abcABC123ABCabc
echo ${stringZ/#abc/XYZ} # XYZABC123ABCabc
# Поиск ведется с начала строки
echo ${stringZ/%abc/XYZ} # abcABC123ABCXYZ
# Поиск ведется с конца строки
</source>
<big>'''Использование awk при работе со строками:'''</big> 
В качестве альтернативы, Bash-скрипты могут использовать средства [[awk]] при работе со строками.
 '''Пример''': '''''Альтернативный способ извлечения подстрок.'''''
<source lang="bash">
#!/bin/bash
# substring-extraction.sh
String=23skidoo1
# 012345678 Bash
# 123456789 awk
# Обратите внимание на различия в индексации:
# Bash начинает индексацию с '0'.
# Awk начинает индексацию с '1'.
echo ${String:2:4} # с 3 позиции (0-1-2), 4 символа
# skid
# В эквивалент в awk: substr(string,pos,length).
echo | awk '
{ print substr("'"${String}"'",3,4) }' # skid
# Передача пустого "echo" по каналу в awk, означает фиктивный ввод,
# делая, тем самым, ненужным предоставление имени файла.
exit 0
</source>

=== Подстановка параметров ===
<big>'''Работа с переменными и/или подстановка их значений'''</big>
 <big>'''''${parameter}'''''</big>
 То же самое, что и '''''$parameter''''', т.е. значение переменной ''parameter''. В отдельных случаях, при возникновении неоднозначности интерпретации, корректно будет работать только такая форма записи: '''''${parameter}'''''. Может использоваться для конкатенации (слияния) строковых переменных.
<source lang="bash">
your_id=${USER}-on-${HOSTNAME}
echo "$your_id"
#
echo "Старый \$PATH = $PATH"
PATH=${PATH}:/opt/bin #Добавление /opt/bin в $PATH.
echo "Новый \$PATH = $PATH"
</source>
 <big>'''''${parameter-default}, ${parameter:-default}'''''</big>
 Если параметр отсутствует, то используется значение по-умолчанию.
<source lang="bash">
echo ${username-`whoami`}
# Вывод результата работы команды `whoami`, если переменная $username не установлена.
</source>
Формы записи '''''${parameter-default}''''' и '''''${parameter:-default}''''' в большинстве случаев можно считать эквивалентными. Дополнительный символ : имеет значение только тогда, когда ''parameter'' определён, но имеет "пустое" (null)значение.
<source lang="bash">
#!/bin/bash
username0=
# переменная username0 объявлена, но инициализирована "пустым" значением.
echo "username0 = ${username0-`whoami`}"
# Вывод после символа "=" отсутствует.
echo "username1 = ${username1-`whoami`}"
# Переменная username1 не была объявлена.
# Выводится имя пользователя, выданное командой `whoami`.
username2=
# переменная username2 объявлена, но инициализирована "пустым" значением.
echo "username2 = ${username2:-`whoami`}"
# Выводится имя пользователя, выданное командой `whoami`, поскольку
# здесь употребляется конструкция ":-" , а не "-".
exit 0
</source>
''Параметры по-умолчанию'' очень часто находят применение в случаях, когда сценарию необходимы какие-либо входные аргументы, передаваемые из командной строки, но такие аргументы не были переданы.
<source lang="bash">
DEFAULT_FILENAME=generic.data
filename=${1:-$DEFAULT_FILENAME}
# Если имя файла не задано явно, то последующие операторы будут работать
# с файлом "generic.data".
</source>

 <big>'''''${parameter=default},${parameter:=default}'''''</big>
 Если значения параметров не заданы явно, то они принимают значения по-умолчанию. Оба метода задания значений по-умолчанию до определенной степени идентичны. Символ '':'' имеет значение только когда ''$parameter'' был инициализирован "пустым" (null) значением, как показано выше.
<source lang="bash">
echo ${username=`whoami`}
# Переменная "username" принимает значение, возвращаемое командой `whoami`.
</source>
 <big>'''''${parameter+alt_value},${parameter:+alt_value}'''''</big>
 Если параметр имеет какое-либо значение, то используется ''alt_value'', иначе — null ("пустая" строка).
Оба варианта до определенной степени идентичны. Символ '':'' имеет значение только если ''parameter'' объявлен и "пустой".
<source lang="bash">
echo "###### \${parameter+alt_value} ########"
echo
a=${param1+xyz}
echo "a = $a" # a =
param2=
a=${param2+xyz}
echo "a = $a" # a = xyz
param3=123
a=${param3+xyz}
echo "a = $a" # a = xyz
echo
echo "###### \${parameter:+alt_value} ########"
echo
a=${param4:+xyz}
echo "a = $a" # a =
param5=
a=${param5:+xyz}
echo "a = $a" # a =
# Вывод отличается от a=${param5+xyz}
param6=123
a=${param6+xyz}
echo "a = $a" # a = xyz
</source>
 <big>'''''${parameter?err_msg},${parameter:?err_msg}'''''</big>
 Если ''parameter'' инициализирован, то используется его значение, в противном случае — выводится ''err_msg''.
Обе формы записи можно, до определенной степени, считать идентичными. Символ '':'' имеет значение только когда ''parameter'' инициализирован "пустым" значением.
 '''Пример''': '''''Подстановка параметров и сообщения об ошибках.'''''
<source lang="bash">
#!/bin/bash
# Проверка отдельных переменных окружения.
# Если переменная, к примеру $USER, не установлена,
# то выводится сообщение об ошибке.
: ${HOSTNAME?} ${USER?} ${HOME?} ${MAIL?}
echo
echo "Имя машины: $HOSTNAME."
echo "Ваше имя: $USER."
echo "Ваш домашний каталог: $HOME."
echo "Ваш почтовый ящик: $MAIL."
echo
echo "Если перед Вами появилось это сообщение,"
echo "то это значит, что все критические переменные окружения установлены."
echo
echo
# ------------------------------------------------------
# Конструкция ${variablename?} так же выполняет проверку
# наличия переменной в сценарии.
ThisVariable=Value-of-ThisVariable
# Обратите внимание, в строковые переменные могут быть записаны
# символы, которые запрещено использовать в именах переменных.
: ${ThisVariable?}
echo "Value of ThisVariable is $ThisVariable".
echo
echo
: ${ZZXy23AB?"Переменная ZZXy23AB не инициализирована."}
# Если ZZXy23AB не инициализирована,
# то сценарий завершается с сообщением об ошибке.
# Текст сообщения об ошибке можно задать свой.
# : ${ZZXy23AB?"Переменная ZZXy23AB не инициализирована."}
# То же самое: dummy_variable=${ZZXy23AB?}
# dummy_variable=${ZZXy23AB?"Переменная ZXy23AB не инициализирована."}
# echo ${ZZXy23AB?} >/dev/null
echo "Это сообщение не будет напечатано, поскольку сценарий завершится раньше."
HERE=0
exit $HERE # Сценарий завершит работу не здесь.
</source>
 '''Пример''': '''''Подстановка параметров и сообщение о "порядке использования".'''''
<source lang="bash">
#!/bin/bash
# usage-message.sh
: ${1?"Порядок использования: $0 ARGUMENT"}
# Сценарий завершит свою работу здесь, если входные аргументы отсутствуют,
# со следующим сообщением.
# usage-message.sh: 1: Порядок использования: usage-message.sh ARGUMENT
echo "Эти две строки появятся, только когда задан аргумент в командной строке."
echo "Входной аргумент командной строки = \"$1\""
exit 0 # Точка выхода находится здесь, только когда задан аргумент командной строки.
# Проверьте код возврата в обеих случаях, с и без аргумента командной строки.
# Если аргумент задан, то код возврата будет равен 0.
# Иначе — 1.
</source>

<big>'''Подстановка параметров и/или экспансия.'''</big>
 Следующие выражения могут служить дополнениями оператора ''match'' команды ''expr'', применяемой к строкам. Как правило, они используются при разборе имён файлов и каталогов.
 <big>'''Длина переменной/Удаление подстроки.'''</big>
 <big>'''''${#var}'''''</big>
 ''String length'' (число символов в переменной ''$var''). В случае массивов, команда ''${#array}'' возвращает длину первого элемента массива.
 '''''Исключения:''''' 
* '''${#*}''' и '''${#@}''' возвращает количество аргументов (позиционных параметров).
* Для массивов, '''${#array[*]}''' и '''${#array[@]}''' возвращает количество элементов в массиве.
 '''Пример''': '''''Длина переменной.'''''
<source lang="bash">
#!/bin/bash
# length.sh
E_NO_ARGS=65if [ $# -eq 0 ] # Для работы скрипта необходим хотя бы один входной параметр.
then
echo "Вызовите сценарий с одним или более параметром командной строки."
exit $E_NO_ARGS
fi
var01=abcdEFGH28ij
echo "var01 = ${var01}"
echo "Length of var01 = ${#var01}"
echo "Количество входных параметров = ${#@}"
echo "Количество входных параметров = ${#*}"
exit 0
</source>
 <big>'''''${var#Pattern},${var##Pattern}'''''</big>
 
Удаляет из переменной ''$var'' наименьшую/наибольшую подстроку, совпадающую с шаблоном ''$Pattern''. Поиск ведётся с начала строки ''$var''.
<source lang="bash">
# Функция из сценария "days-between.sh".
95
# Удаляет нули, стоящие в начале аргумента-строки.
strip_leading_zero () # Ведущие нули, которые могут находиться в номере дня/месяца, лучше удалить
{ # В противном случае Bash будет интерпретировать числа как восьмеричные
return=${1#0} # "1" — это аргумент "$1".
} # "0" — это то, что удаляется из "$1" — ведущие нули.
</source>
'''Manfred Schwarb''' предложил более сложный вариант вышеприведенного кода:
<source lang="bash">
strip_leading_zero2 () # Удалить ведущие нули.
{
shopt -s extglob # Переход в режим расширенной подстановки.
local val=${1##+(0)} # Поиск самой длинной последовательности нулей.
shopt -u extglob # выход из режима расширенной подстановки.
_strip_leading_zero2=${val:-0}
# Если был введен 0, то возвращается 0, а не "".
}
</source>
Другой пример:
<source lang="bash">
echo `basename $PWD` # Имя текущего рабочего каталога.
echo "${PWD##*/}" # Имя текущего рабочего каталога.
echo
echo `basename $0` # Имя файла-сценария.
echo $0 # Имя файла-сценария.
echo "${0##*/}" # Имя файла-сценария.
echo
filename=test.data
echo "${filename##*.}" # data
# Расширение файла.
</source>
 <big>'''''${var%Pattern},${var%%Pattern}'''''</big>
 Удаляет из переменной ''$var'' наименьшую/наибольшую подстроку, совпадающую с шаблоном ''$Pattern''. Поиск ведётся с конца строки ''$var''.Bash версии 2 имеет ряд дополнительных возможностей.
 '''Пример''': '''''Поиск по шаблону в подстановке параметров.'''''
<source lang="bash">
#!/bin/bash
# Поиск по шаблону в операциях подстановки параметров # ## % %%.
var1=abcd12345abc6789
pattern1=a*c # * (символ шаблона), означает любые символы между a и c.
echo
echo "var1 = $var1" # abcd12345abc6789
echo "var1 = ${var1}" # abcd12345abc6789 (альтернативный вариант)
echo "Число символов в ${var1} = ${#var1}"
echo "pattern1 = $pattern1" # a*c (между 'a' и 'c' могут быть любые символы)
echo
echo '${var1#$pattern1} =' "${var1#$pattern1}" # d12345abc6789
# Наименьшая подстрока, удаляются первые 3 символа abcd12345abc6789
^^^^^^ |-|
echo '${var1##$pattern1} =' "${var1##$pattern1}" # 6789
# Наибольшая подстрока, удаляются первые 12 символов abcd12345abc6789
# ^^^^^^ |----------|
echo; echo
pattern2=b*9 # все, что между 'b' и '9'
echo "var1 = $var1" # abcd12345abc6789
echo "pattern2 = $pattern2"
echo
echo '${var1%pattern2} =' "${var1%$pattern2}" # abcd12345a
# Наименьшая подстрока, удаляются последние 6 символов abcd12345abc6789
# ^^^^^^^^^ |----|
echo '${var1%%pattern2} =' "${var1%%$pattern2}" # a
# Наибольшая подстрока, удаляются последние 12 символов abcd12345abc6789
# ^^^^^^^^^ |-------------|
# Запомните, # и ## используются для поиска с начала строки,
# % и %% используются для поиска с конца строки.
echo
exit 0
</source>
 '''Пример''': '''''Изменение расширений в именах файлов.'''''
<source lang="bash">
#!/bin/bash
# rfe
# ---
# Изменение расширений в именах файлов.
#
# rfe old_extension new_extension
# Пример:
# Изменить все расширения *.gif в именах файлов на *.jpg, в текущем каталоге
# rfe gif jpg
ARGS=2
E_BADARGS=65
if [ $# -ne "$ARGS" ]
then
echo "Порядок использования: `basename $0` old_file_suffix new_file_suffix"
exit $E_BADARGS
fi
for filename in *.$1
# Цикл прохода по списку имен файлов, имеющих расширение равное первому аргументу.
do
mv $filename ${filename%$1}$2
# Удалить первое расширение и добавить второе,
done
exit 0
</source>
 <big>'''Подстановка значений переменных / Замена подстроки'''</big>
 Эти конструкции перекочевали в Bash из ksh.
 <big>'''''${var:pos}'''''</big>
 Подставляется значение переменной ''var'', начиная с позиции ''pos''.
 <big>'''''${var:pos:len}'''''</big>
 Подставляется значение переменной ''var'', начиная с позиции ''pos'', не более ''len'' символов.
 <big>'''''${var/Pattern/Replacement}'''''</big>
 Первое совпадение с шаблоном ''Pattern'', в переменной ''var'' замещается подстрокой ''Replacement''. Если подстрока ''Replacement'' отсутствует, то найденное совпадение будет удалено.
 <big>'''''${var//Pattern/Replacement}'''''</big>
 '''Глобальная замена'''. Все найденные совпадения с шаблоном ''Pattern'', в переменной ''var'', будут замещены подстрокой ''Replacement''. Как и в первом случае, если подстрока ''Replacement'' отсутствует, то все найденные совпадения будут удалены.
 '''Пример''': '''''Поиск по шаблону при анализе произвольных строк.'''''
<source lang="bash">
#!/bin/bash
var1=abcd-1234-defg
echo "var1 = $var1"
t=${var1#*-*}
echo "var1 (все, от начала строки по первый символ \"-\", включительно, удаляется) = $t"
# t=${var1#*-} то же самое,
# поскольку оператор # ищет кратчайшее совпадение,
# а * соответствует любым предшествующим символам, включая пустую строку.
# (Спасибо S. C. за разъяснения.)
t=${var1##*-*}
echo "Если var1 содержит \"-\", то возвращается пустая строка... var1 = $t"
t=${var1%*-*}
echo "var1 (все, начиная с последнего \"-\" удаляется) = $t"
echo
# -------------------------------------------
path_name=/home/bozo/ideas/thoughts.for.today
# -------------------------------------------
echo "path_name = $path_name"
t=${path_name##/*/}
echo "Из path_name удален путь к файлу = $t"
# В данном случае, тот эе эффект можно получить так: t=`basename $path_name`
# t=${path_name%/}; t=${t##*/} более общее решение,
# но имеет некоторые ограничения.
# Если $path_name заканчивается символом перевода строки, то `basename $path_name` не будет работать,
# но для данного случая вполне применимо.
# (Спасибо S.C.)
t=${path_name%/*.*}
# Тот же эффект дает t=`dirname $path_name`
echo "Из path_name удалено имя файла = $t"
# Этот вариант будет терпеть неудачу в случаях: "../", "/foo////", # "foo/", "/".
# Удаление имени файла, особенно когда его нет,
# использование dirname имеет свои особенности.
# (Спасибо S.C.)
echo
t=${path_name:11}
echo "Из $path_name удалены первые 11 символов = $t"
t=${path_name:11:5}
echo "Из $path_name удалены первые 11 символов, выводится 5 символов = $t"
echo
t=${path_name/bozo/clown}
echo "В $path_name подстрока \"bozo\" заменена на \"clown\" = $t"
t=${path_name/today/}
echo "В $path_name подстрока \"today\" удалена = $t"
t=${path_name//o/O}
echo "В $path_name все символы \"o\" переведены в верхний регистр, = $t"
t=${path_name//o/}
echo "Из $path_name удалены все символы \"o\" = $t"
exit 0
</source>
 <big>'''''${var/#Pattern/Replacement}'''''</big>
 Если в переменной ''var'' найдено совпадение с ''Pattern'', причём совпадающая подстрока расположена в начале строки (префикс), то оно заменяется на ''Replacement''. Поиск ведётся сначала строки.
 <big>'''''${var/%Pattern/Replacement}'''''</big>
 Если в переменной ''var'' найдено совпадение с ''Pattern'', причём совпадающая подстрока расположена в конце строки (суффикс), то оно заменяется на ''Replacement''. Поиск ведётся с конца строки.
 '''Пример''': '''''Поиск префиксов и суффиксов с заменой по шаблону.'''''
<source lang="bash">
#!/bin/bash
# Поиск с заменой по шаблону.
v0=abc1234zip1234abc # Начальное значение переменной.
echo "v0 = $v0" # abc1234zip1234abc
echo
# Поиск совпадения с начала строки.
v1=${v0/#abc/ABCDEF} # abc1234zip1234abc
# |-|
echo "v1 = $v1" # ABCDE1234zip1234abc
# |---|
# Поиск совпадения с конца строки.
v2=${v0/%abc/ABCDEF} # abc1234zip123abc
# |-|
echo "v2 = $v2" # abc1234zip1234ABCDEF
# |----|
echo
# ----------------------------------------------------
# Если совпадение находится не с начала/конца строки,
# то замена не производится.
# ----------------------------------------------------
v3=${v0/#123/000} # Совпадение есть, но не в начале строки.
echo "v3 = $v3" # abc1234zip1234abc
# ЗАМЕНА НЕ ПРОИЗВОДИТСЯ!
v4=${v0/%123/000} # Совпадение есть, но не в конце строки.
echo "v4 = $v4" # abc1234zip1234abc
# ЗАМЕНА НЕ ПРОИЗВОДИТСЯ!
exit 0
</source>
 <big>'''''${!varprefix*},${!varprefix@}'''''</big>
 Поиск по шаблону всех, ранее объявленных переменных, имена которых начинаются с ''varprefix''.
<source lang="bash">
xyz23=whatever
xyz24=
a=${!xyz*} # Подстановка имен объявленных переменных, которые начинаются с "xyz".
echo "a = $a" # a = xyz23 xyz24
a=${!xyz@} # То же самое.
echo "a = $a" # a = xyz23 xyz24
# Эта возможность была добавлена в Bash, в версии 2.04.
</source>

=== Объявление переменных: declare и typeset ===
Инструкции '''declare''' и '''typeset''' являются встроенными инструкциями (они абсолютно идентичны друг другу и являются синонимами) и предназначена для наложения ограничений на переменные. Это очень слабая попытка контроля над типами, которая имеется во многих языках программирования. Инструкция '''declare''' появилась в Bash, начиная с версии 2. Кроме того, инструкция '''typeset''' может использоваться и в ksh-сценариях.
<big>'''Ключи инструкций declare/typeset'''</big>
 <big>'''''<big>-r</big> readonly (только для чтения)'''''</big>
 '''''declare -r var1'''''
 (declare -r var1 аналогично объявлению readonly var1).
 Это грубый эквивалент констант (''const'') в языке C. Попытка изменения таких переменных завершается сообщением об ошибке.
 <big>'''''<big>-i</big> integer'''''</big>
 '''''declare -i number'''''
# Сценарий интерпретирует переменную "number" как целое число.
number=3
echo "number = $number" # number = 3
number=three
echo "number = $number" # number = 0
# Строка "three" интерпретируется как целое число.
Допускается выполнение некоторых арифметических операций над переменными, объявленными как integer, не прибегая к инструкциям ''expr'' или ''let''.
n=6/3
echo "n = $n" # n = 6/3
declare -i n
n=6/3
echo "n = $n" # n = 2
<big>'''''<big>-a</big> array'''''</big>
 '''''declare -a indices'''''
 Переменная ''indices'' объявляется массивом.
 <big>'''''<big>-f</big> functions'''''</big>
 '''''declare -f'''''
 Инструкция ''declare -f'', без аргументов, приводит к выводу списка ранее объявленных функций в сценарии.
 '''''declare -f function_name'''''
 Инструкция ''declare -f function_name'' выводит имя функции ''function_name'', если она была объявлена ранее.
 <big>'''''<big>-x</big> export'''''</big>
 '''''declare -x var3'''''
 Эта инструкция объявляет переменную, как доступную для экспорта.
 <big>'''''<big>-x</big> var=$value'''''</big>
 '''''declare -x var3=373'''''
 Инструкция ''declare'' допускает совмещение объявления и присваивания значения переменной одновременно.
 '''Пример''': '''''Объявление переменных с помощью инструкции declare.'''''
<source lang="bash">
#!/bin/bash
func1 ()
{
echo Это функция.
}
declare -f # Список функций, объявленных выше.
echo
declare -i var1 # var1 — целочисленная переменная.
var1=2367
echo "переменная var1 объявлена как $var1"
var1=var1+1 # Допустимая арифметическая операция над целочисленными переменными.
echo "переменная var1 увеличена на 1 = $var1."
# Допустимая операция для целочисленных переменных
echo "Возможно ли записать дробное число 2367.1 в var1?"
var1=2367.1 # Сообщение об ошибке, переменная не изменяется.
echo "значение переменной var1 осталось прежним = $var1"
echo
declare -r var2=13.36 # инструкция 'declare' допускает установку свойств переменной
# и одновременно присваивать значение.
echo "var2 declared as $var2" # Допускается ли изменять значение readonly переменных?
var2=13.37 # Сообщение об ошибке и завершение работы сценария.
echo "значение переменной var2 осталось прежним $var2" # Эта строка никогда не будет выполнена.
exit 0 # Сценарий завершит работу выше.
</source>

=== Косвенные ссылки на переменные ===
Предположим, что значение одной переменной — есть имя второй переменной. Возможно ли получить значение второй переменной через обращение к первой? Например, пусть ''a=letter_of_alphabet'' и ''letter_of_alphabet=z'', тогда вопрос будет звучать так: "Возможно ли получить значение ''z'', обратившись к переменной ''a''?". В действительности это возможно и это называется ''косвенной ссылкой''. Для этого необходимо прибегнуть к несколько необычной нотации ''eval var1=\$$var2''.
 '''Пример''': '''''Косвенные ссылки.'''''
<source lang="bash">
#!/bin/bash
# Косвенные ссылки на переменные.
a=letter_of_alphabet
letter_of_alphabet=z
echo
# Прямое обращение к переменной.
echo "a = $a"
# Косвенное обращение к переменной.
eval a=\$$a
echo "А теперь a = $a"
echo
# Теперь попробуем изменить переменную, на которую делается ссылка.
t=table_cell_3
table_cell_3=24
echo "\"table_cell_3\" = $table_cell_3"
echo -n "разыменование (получение ссылки) \"t\" = "; eval echo \$$t
# В данном, простом, случае,
# eval t=\$$t; echo "\"t\" = $t"
# даёт тот же результат (почему?).
echo
t=table_cell_3
NEW_VAL=387
table_cell_3=$NEW_VAL
echo "Значение переменной \"table_cell_3\" изменено на $NEW_VAL."
echo "Теперь \"table_cell_3\" = $table_cell_3"
echo -n "разыменование (получение ссылки) \"t\" = "; eval echo \$$t
# инструкция "eval" принимает два аргумента "echo" и "\$$t" (назначает равным $table_cell_3)
echo
# (Спасибо S.C. за разъяснения.)
# Ещё один способ — нотация ${!t}, будет обсуждаться в разделе "Bash, версия 2".
exit 0
</source>

 '''Пример''': '''''Передача косвенных ссылок в awk.'''''
<source lang="bash">
#!/bin/bash
# Другая версия сценария "column totaler"
# который суммирует заданную колонку (чисел) в заданном файле.
# Здесь используются косвенные ссылки.
ARGS=2
E_WRONGARGS=65
if [ $# -ne "$ARGS" ] # Проверка количества входных аргументов.
then
echo "Порядок использования: `basename $0` filename column-number"
exit $E_WRONGARGS
fi
filename=$1
column_number=$2
#===== До этой строки идентично первоначальному варианту сценария =====#
# Многострочные скрипты awk вызываются конструкцией awk ' ..... '
# Начало awk-сценария.
# ------------------------------------------------
awk "
{ total += \$${column_number} # косвенная ссылка
}
END {
print total
}
" "$filename"
# ------------------------------------------------
# Конец awk-сценария.
# Косвенные ссылки делают возможным бесконфликтное
# обращение к переменным shell внутри вложенных сценариев awk.
# Спасибо Stephane Chazelas.
exit 0
</source>
Такой метод обращения к переменным имеет свои особенности. Если переменная, на которую делается ссылка, меняет свое значение, то переменная которая ссылается, должна быть должным образом разыменована, т.е. должна быть выполнена операция получения ссылки, как это делается в примере выше. К счастью, нотация ''${!variable}'', введённая в Bash, начиная с версии 2 позволяет выполнять косвенные ссылки более интуитивно понятным образом.

=== $RANDOM: генерация псевдослучайных целых чисел ===
'''$RANDOM''' — внутренняя функция Bash (не константа), которая возвращает ''псевдослучайные целые числа'' в диапазоне 0—32767. Функция '''$RANDOM''' ''не должна'' использоваться для генерации ключей шифрования.
 '''Пример''': '''''Генерация случайных чисел.'''''
<source lang="bash">
#!/bin/bash
# $RANDOM возвращает различные случайные числа при каждом обращении к ней.
# Диапазон изменения: 0—32767 (16-битовое целое со знаком).
MAXCOUNT=10
count=1
echo
echo "$MAXCOUNT случайных чисел:"
echo "-----------------"
while [ "$count" -le $MAXCOUNT ] # Генерация 10 ($MAXCOUNT) случайных чисел.
do
number=$RANDOM
echo $number
let "count += 1" # Нарастить счетчик.
done
echo "-----------------"
# Если вам нужны случайные числа не превышающие определенного числа,
# воспользуйтесь оператором деления по модулю (остаток от деления).
RANGE=500
echo
number=$RANDOM
let "number %= $RANGE"
echo "Случайное число меньше $RANGE —— $number"
echo
# Если вы желаете ограничить диапазон "снизу",
# то просто производите генерацию псевдослучайных чисел в цикле до тех пор,
# пока не получите число большее нижней границы.
FLOOR=200
number=0 # инициализация
while [ "$number" -le $FLOOR ]
do
number=$RANDOM
done
echo "Случайное число, большее $FLOOR —— $number"
echo
# Эти два способа могут быть скомбинированы.
number=0 #initialize
while [ "$number" -le $FLOOR ]
do
number=$RANDOM
let "number %= $RANGE" # Ограничение "сверху" числом $RANGE.
done
echo "Случайное число в диапазоне от $FLOOR до $RANGE —— $number"
echo
# Генерация случайных "true" и "false" значений.
BINARY=2
number=$RANDOMT=1
let "number %= $BINARY"
# let "number >>= 14" даёт более равномерное распределение
# (сдвиг вправо смещает старший бит на нулевую позицию, остальные биты
обнуляются).
if [ "$number" -eq $T ]
then
echo "TRUE"
else
echo "FALSE"
fi
echo
# Можно имитировать бросание 2-х игровых кубиков.
SPOTS=7 # остаток от деления на 7 дает диапазон 0 - 6.
ZERO=0
die1=0
die2=0
# Кубики "выбрасываются" раздельно.
while [ "$die1" -eq $ZERO ] # Пока на "кубике" ноль.
do
let "die1 = $RANDOM % $SPOTS" # Имитировать бросок первого кубика.
done
while [ "$die2" -eq $ZERO ]
do
let "die2 = $RANDOM % $SPOTS" # Имитировать бросок второго кубика.
done
let "throw = $die1 + $die2"
echo "Результат броска кубиков = $throw"
echo
exit 0
</source>
 '''Пример''': '''''Выбор случайной карты из колоды.'''''
<source lang="bash">
#!/bin/bash
# pick-card.sh
# Пример выбора случайного элемента массива.
# Выбор случайной карты из колоды.
Suites="Треф
Бубей
Червей
Пик"
Denominations="2
3
4
5
6
7
8
9
10
Валет
Дама
Король
Туз"
# Инициализация массивов.
suite=($Suites)
denomination=($Denominations)
num_suites=${#suite[*]} # Количество элементов массивов.
num_denominations=${#denomination[*]}
echo -n "${denomination[$((RANDOM%num_denominations))]} "
echo ${suite[$((RANDOM%num_suites))]}
# $bozo sh pick-cards.sh
# Валет Треф
# Спасибо "jipe," за пояснения по работе с $RANDOM.
exit 0
</source>
'''''Jipe''''' подсказал ещё один способ генерации случайных чисел из заданного диапазона.
<source lang="bash">
# Генерация случайных чисел в диапазоне 6—30.
rnumber=$((RANDOM%25+6))
# Генерируется случайное число из диапазона 6—30,
# но при этом число должно делиться на 3 без остатка.
rnumber=$(((RANDOM%30/3+1)*3))
# Примечательно, если $RANDOM возвращает 0
# то это приводит к возникновению ошибки.
# Упражнение: Попробуйте разобраться с выражением самостоятельно.
</source>
'''''Bill Gradwohl''''' предложил усовершенствованную формулу генерации положительных псевдослучайных чисел в заданном диапазоне.
<source lang="bash">
rnumber=$(((RANDOM%(max-min+divisibleBy))/divisibleBy*divisibleBy+min))
</source>
В сценарии ниже, '''''Bill''''' представил универсальную функцию, которая возвращает псевдослучайное число из заданного диапазона.
 '''Пример''': '''''Псевдослучайное число из заданного диапазона.'''''
<source lang="bash">
#!/bin/bash
# random-between.sh
# Псевдослучайное число из заданного диапазона.
# Автор: Bill Gradwohl,
# незначительные изменения внесены автором документа.
# Используется с разрешения автора сценария.
randomBetween() {
# Генерация положительных и отрицательных псевдослучайных чисел,
# в диапазоне от $min до $max,
# которые кратны числу $divisibleBy.
#
# Bill Gradwohl — Oct 1, 2003
syntax() {
# Вложенная функция.
echo
echo "Порядок вызова: randomBetween [min] [max] [multiple]"
echo
echo "Функция ожидает до 3-х входных аргументов, но они не являются обязательными."
echo "min — нижняя граница диапазона"
echo "max — верхняя граница диапазона"
echo "multiple — делитель, на который должен делиться результат без остатка."
echo
echo "Если какой либо из параметров отсутствует, по-умолчанию принимаются значения: 0 32767 1"
echo "В случае успеха функция возвращает 0, иначе — 1"
echo "и это сообщение о порядке вызова."
echo "Результат возвращается в глобальной переменной randomBetweenAnswer"
echo "Входные параметры, имеющие отрицательные значения, обрабатываются корректно."
}
local min=${1:-0}
local max=${2:-32767}
local divisibleBy=${3:-1}
# При отсутствии какого-либо из входных параметров, они принимают значения по-умолчанию.
local x
local spread
# Делитель должен быть положительным числом.
[ ${divisibleBy} -lt 0 ] && divisibleBy=$((0-divisibleBy))
# Проверка корректности входных параметров.
if [ $# -gt 3 -o ${divisibleBy} -eq 0 -o ${min} -eq ${max} ]; then
syntax
return 1
fi
# Если min больше чем max, то поменять их местами.
if [ ${min} -gt ${max} ]; then
# Поменять местами.
x=${min}
min=${max}
max=${x}
fi
# Если min не делится без остатка на $divisibleBy,
# то привести его к ближайшему подходящему числу из заданного диапазона.
if [ $((min/divisibleBy*divisibleBy)) -ne ${min} ]; then
if [ ${min} -lt 0 ]; then
min=$((min/divisibleBy*divisibleBy))
else
min=$((((min/divisibleBy)+1)*divisibleBy))
fi
fi
# Если max не делится без остатка на $divisibleBy,
# то привести его к ближайшему подходящему числу из заданного диапазона.
if [ $((max/divisibleBy*divisibleBy)) -ne ${max} ]; then
if [ ${max} -lt 0 ]; then
max=$((((max/divisibleBy)-1)*divisibleBy))
else
max=$((max/divisibleBy*divisibleBy))
fi
fi
# ---------------------------------------------------------------------
# А теперь собственно нахождение псевдослучайного числа.
# Обратите внимание: чтобы получить псевдослучайное число в конце диапазона
# необходимо рассматривать диапазон от 0 до
# abs(max-min)+divisibleBy, а не abs(max-min)+1.
# Этим превышением верхней границы диапазона можно пренебречь
# поскольку эта новая граница никогда не будет достигнута.

# Если использовать при вычислении формулу abs(max-min)+1,
# то будут получаться вполне корректные значения, но при этом,
# возвращаемые значения будут значительно ниже
# верхней границы диапазона.
# ---------------------------------------------------------------------
spread=$((max-min))
[ ${spread} -lt 0 ] && spread=$((0-spread))
let spread+=divisibleBy
randomBetweenAnswer=$(((RANDOM%spread)/divisibleBy*divisibleBy+min))
return 0
}
# Проверка функции.
min=-14
max=20
divisibleBy=3
# Создадим массив, который будет содержать счетчики встречаемости каждого из чисел
# в заданном диапазоне.
declare -a answer
minimum=${min}
maximum=${max}
if [ $((minimum/divisibleBy*divisibleBy)) -ne ${minimum} ]; then
if [ ${minimum} -lt 0 ]; then
minimum=$((minimum/divisibleBy*divisibleBy))
else
minimum=$((((minimum/divisibleBy)+1)*divisibleBy))
fi
fi

# Если max не делится без остатка на $divisibleBy,
# то привести его к ближайшему подходящему числу из заданного диапазона.
if [ $((maximum/divisibleBy*divisibleBy)) -ne ${maximum} ]; then
if [ ${maximum} -lt 0 ]; then
maximum=$((((maximum/divisibleBy)-1)*divisibleBy))
else
maximum=$((maximum/divisibleBy*divisibleBy))
fi
fi

# Необходимое условие при работе с массивами —
# индекс массива должен быть положительным числом,
# поэтому введена дополнительная переменная displacement, которая
# гарантирует положительность индексов.
displacement=$((0-minimum))
for ((i=${minimum}; i<=${maximum}; i+=divisibleBy)); do
answer[i+displacement]=0
done
# Цикл с большим количеством итераций, чтобы посмотреть - что мы получаем.
loopIt=1000 # Автор сценария предложил 100000 итераций,
# но в этом случае цикл работает чересчур долго.
for ((i=0; i<${loopIt}; ++i)); do
# Обратите внимание: числа min и max передаются функции в обратном порядке,
# чтобы продемонстрировать, что функция обрабатывает их корректно.
randomBetween ${max} ${min} ${divisibleBy}
# Вывод сообщения об ошибке, если функция вернула некорректное значение.
[ ${randomBetweenAnswer} -lt ${min} -o ${randomBetweenAnswer} -gt ${max} ] && echo \
"Выход за границы диапазона MIN..MAX" - ${randomBetweenAnswer}!
[ $((randomBetweenAnswer%${divisibleBy})) -ne 0 ] && echo Число не делится на заданный делитель без остатка - ${randomBetweenAnswer}!
# Записать полученное число в массив.
answer[randomBetweenAnswer+displacement]=$((answer[randomBetweenAnswer+displacement]+1))
done
# Проверим полученные результаты
for ((i=${minimum}; i<=${maximum}; i+=divisibleBy)); do
[ ${answer[i+displacement]} -eq 0 ] && echo "Число $i не было получено ни разу." || echo \
"Число ${i} встречено ${answer[i+displacement]} раз."
done
exit 0
</source>
Насколько случайны числа, возвращаемые функцией $RANDOM? Лучший способ оценить"случайность" генерируемых чисел — это написать сценарий, который будет имитировать бросание игрального кубика достаточно большое число раз, а затем выведет количество выпадений каждой из граней...
 '''Пример''': '''''Имитация бросания кубика с помощью RANDOM.'''''
<source lang="bash">
#!/bin/bash
# Случайные ли числа возвращает RANDOM?
RANDOM=$$ # Инициализация генератора случайных чисел числом PID процесса-сценария.
PIPS=6 # Кубик имеет 6 граней.
MAXTHROWS=600 # Можете увеличить, если не знаете куда девать свое время.
throw=0 # Счётчик бросков.
zeroes=0 # Обнулить счётчики выпадения отдельных граней.
ones=0 # т.к. неинициализированные переменные - "пустые", и не равны нулю!.
twos=0
threes=0
fours=0
fives=0
sixes=0

print_result ()
{
echo
echo "единиц = $ones"
echo "двоек = $twos"
echo "троек = $threes"
echo "четвёрок = $fours"
echo "пятёрок = $fives"
echo "шестёрок = $sixes"
echo
}

update_count()
{
case "$1" in
0) let "ones += 1";; # 0 соответствует грани "1".
1) let "twos += 1";; # 1 соответствует грани "2", и так далее
2) let "threes += 1";;
3) let "fours += 1";;
4) let "fives += 1";;
5) let "sixes += 1";;
esac
}

echo

while [ "$throw" -lt "$MAXTHROWS" ]
do
let "die1 = RANDOM % $PIPS"
update_count $die1
let "throw += 1"
done

print_result
# Количество выпадений каждой из граней должно быть примерно одинаковым, если считать RANDOM достаточно случайным.
# Для $MAXTHROWS = 600, каждая грань должна выпасть примерно 100 раз (плюс-минус 20).
#
# Имейте ввиду, что RANDOM - это генератор ПСЕВДОСЛУЧАЙНЫХ чисел,
# Упражнение:
# ---------------
# Перепишите этот сценарий так, чтобы он имитировал 1000 бросков монеты.
# Перепишите этот сценарий так, чтобы он имитировал 1000 бросков монеты.
# На каждом броске возможен один из двух вариантов выпадения — "ОРЁЛ" или "РЕШКА".
exit 0
</source>
Как видно из последнего примера, неплохо было бы производить переустановку начального числа генератора случайных чисел RANDOM перед тем, как начать работу с ним. Если используется одно и тоже начальное число, то генератор RANDOM будет выдавать одну и ту же последовательность чисел.(Это совпадает с поведением функции random() в языке C.)
 '''Пример''': '''''Переустановка RANDOM.'''''
<source lang="bash">
#!/bin/bash
# seeding-random.sh: Переустановка переменной RANDOM.
MAXCOUNT=25 # Длина генерируемой последовательности чисел.

random_numbers ()
{
count=0
while [ "$count" -lt "$MAXCOUNT" ]
do
number=$RANDOM
echo -n "$number "
let "count += 1"
done
}

echo; echo
RANDOM=1 # Переустановка начального числа генератора случайных чисел RANDOM.
random_numbers
echo; echo
RANDOM=1 # То же самое начальное число...
random_numbers # ...в результате получается та же последовательность чисел.
# В каких случаях может оказаться полезной генерация совпадающих серий?
echo; echo
RANDOM=2 # Ещё одна попытка, но с другим начальным числом...
random_numbers # получим другую последовательность.
echo; echo
# RANDOM=$$ в качестве начального числа выбирается PID процесса-сценария.
# Вполне допустимо взять в качестве начального числа результат работы команд 'time' или 'date'.
# Немного воображения...
SEED=$(head -1 /dev/urandom | od -N 1 | awk '{ print $2 }')
# Псевдослучайное число забирается
# из системного генератора псевдослучайных чисел /dev/urandom,
# затем конвертируется в восьмеричное число командой "od",
# и наконец "awk" возвращает единственное число для переменной SEED.
RANDOM=$SEED
random_numbers
echo; echo
exit 0
</source>
Системный генератор ''/dev/urandom'' даёт последовательность псевдослучайных чисел с более равномерным распределением, чем $RANDOM. Команда ''[[dd]] if=/dev/urandom of=targetfile bs=1count=XX'' создаёт файл, содержащий последовательность псевдослучайных чисел. Однако, эти числа требуют дополнительной обработки, например с помощью команды [[od]] (этот приём используется в примере выше) или [[dd]]. Есть и другие способы генерации псевдослучайных последовательностей в сценариях. [[Awk]] имеет для этого достаточно удобные средства.
 '''Пример''': '''''Получение псевдослучайных чисел с помощью awk.'''''
<source lang="bash">
#!/bin/bash
# random2.sh: Генерация псевдослучайных чисел в диапазоне 0 - 1.
# Используется функция rand() из awk.
AWKSCRIPT=' { srand(); print rand() } '
# Команды/параметры, передаваемые awk
# Обратите внимание, функция srand() переустанавливает начальное число генератора случайных чисел
echo -n "Случайное число в диапазоне от 0 до 1 = "
echo | awk "$AWKSCRIPT"
exit 0
# Упражнения:
# ---------
# 1) С помощью оператора цикла выведите 10 различных случайных чисел.
# (Подсказка: вам потребуется вызвать функцию "srand()"
# в каждом цикле с разными начальными числами.
# Что произойдет, если этого не сделать?)
# 2) Заставьте сценарий генерировать случайные числа в диапазоне 10 - 100
# используя целочисленный множитель, как коэффициент масштабирования
# 3) То же самое, что и во втором упражнении,
# но на этот раз случайные числа должны быть целыми.
</source>
Кроме того, команда [[date]] так же может использоваться для генерации ''псевдослучайных целых чисел''.
Также при необходимости сгенерировать несколько целых чисел в shell-скрипте можно воспользоваться командой shuf.
Следующая команда сгенерирует одно целое число в диапазоне от 100000 до 999999:
<source lang="bash">
shuf -i 100000-999999 -n 1
</source>
После ключа '''-n''' может быть любое положительное число, задающее количество(!) генерируемых чисел.

=== Двойные круглые скобки ===
Эта конструкция во многом похожа на инструкцию [[let]], внутри '''((...))''' вычисляются арифметические выражения и возвращается их результат. В простейшем случае, конструкция ''a=$(( 5 + 3 ))'' присвоит переменной "a" значение выражения "5 + 3", или 8. Но, кроме того, двойные круглые скобки позволяют работать с переменными в стиле языка C.
 '''Пример''': '''''Работа с переменными в стиле языка C.'''''
<source lang="bash">
#!/bin/bash
echo
(( a = 23 )) # Присвоение переменной в стиле C, с обоих строн от "=" стоят пробелы.
echo "a (начальное значение) = $a"
(( a++ )) # Пост-инкремент 'a', в стиле C.
echo "a (после a++) = $a"
(( a-- )) # Пост-декремент 'a', в стиле C.
echo "a (после a--) = $a"
(( ++a )) # Пред-инкремент 'a', в стиле C.
echo "a (после ++a) = $a"
(( --a )) # Пред-декремент 'a', в стиле C.
echo "a (после --a) = $a"
echo
(( t = a<45?7:11 )) # Трехместный оператор в стиле языка C.
echo "If a < 45, then t = 7, else t = 11."
echo "t = $t " # Да!
echo# См. так же описание ((...)) в циклах "for" и "while".
# Эта конструкция доступна в Bash, начиная с версии 2.04.
exit 0
</source>

== Циклы и ветвления ==
Управление ходом исполнения — один из ключевых моментов структурной организации сценариев на языке командной оболочки. Циклы и переходы являются теми инструментальными средствами, которые обеспечивают управление порядком исполнения команд.
=== Циклы ===
''Цикл'' — это блок команд, который исполняется многократно до тех пор, пока не будет выполнено условие выхода из цикла.

<big>'''Циклы for'''</big> 
<big>'''for (in)'''</big> 
Это одна из основных разновидностей циклов. И она значительно отличается от аналога в языке C.
<source lang="bash">
for arg in [list]
do
команда(ы)...
done
</source>
На каждом проходе цикла, переменная-аргумент цикла ''arg'' последовательно,одно за другим, принимает значения из списка ''list''.
<source lang="bash">
for arg in "$var1" "$var2" "$var3" ... "$varN"
# На первом проходе, $arg = $var1
# На втором проходе, $arg = $var2
# На третьем проходе, $arg = $var3
# ...
# На N-ном проходе, $arg = $varN
# Элементы списка заключены в кавычки для того, чтобы предотвратить возможное разбиение их на отдельные аргументы (слова).
</source>
Элементы списка могут включать в себя шаблонные символы. Если ключевое слово '''do''' находится в одной строке со словом '''for''', то после списка аргументов(перед '''do''') необходимо ставить точку с запятой.
<source lang="bash">
for arg in [list] ; do
</source>
 '''Пример''': '''''Простой цикл for.'''''
<source lang="bash">
#!/bin/bash
# Список планет.
for planet in Меркурий Венера Земля Марс Юпитер Сатурн Уран Нептун Плутон
do
echo $planet
done
echo # Если 'список аргументов' заключить в кавычки, то он будет восприниматься как единственный аргумент.
for planet in "Меркурий Венера Земля Марс Юпитер Сатурн Уран Нептун Плутон"
do
echo $planet
done
exit 0
</source>
Каждый из элементов [списка] может содержать несколько аргументов. Это бывает полезным при обработке групп параметров. В этом случае, для принудительного разбора каждого из аргументов в списке, необходимо использовать инструкцию ''set''.
 '''Пример''': '''''Цикл for с двумя параметрами в каждом из элементов списка.'''''
<source lang="bash">
#!/bin/bash
# Список планет.
# Имя каждой планеты ассоциировано с расстоянием от планеты до Солнца (млн. миль).
for planet in "Меркурий 36" "Венера 67" "Земля 93" "Марс 142" "Юпитер 483"
do
set -- $planet # Разбиение переменной "planet" на множество аргументов (позиционных параметров).
# Конструкция "--" предохраняет от неожиданностей, если $planet "пуста" или начинается с символа "-".
# Если каждый из аргументов потребуется сохранить, поскольку на следующем проходе они будут "забиты" новыми значениями,
# То можно поместить их в массив,
# original_params=("$@")
echo "$1 в $2,000,000 миль от Солнца"
#----две табуляции---к параметру $2 добавлены нули
done
#(Спасибо S.C., за разъяснения.)
exit 0
</source>
В качестве списка, в цикле ''for'', можно использовать переменную.
 '''Пример''': '''''Fileinfo: обработка списка файлов, находящегося в переменной.'''''
<source lang="bash">
#!/bin/bash
# fileinfo.sh
FILES="/usr/sbin/privatepw
/usr/sbin/pwck
/usr/sbin/go500gw
/usr/bin/fakefile
/sbin/mkreiserfs
/sbin/ypbind" # Список интересующих нас файлов.
# В список добавлен фиктивный файл /usr/bin/fakefile.
echo
for file in $FILES
do
if [ ! -e "$file" ] # Проверка наличия файла.
then
echo "Файл $file не найден."; echo
continue # Переход к следующей итерации.
fi
ls -l $file | awk '{ print $8 " размер: " $5 }' # Печать 2 полей.
whatis `basename $file` # Информация о файле.
echo
done
exit 0
</source>
В [списке] цикла ''for'' могут быть использованы имена файлов, которые в свою очередь могут содержать символы-шаблоны.
 '''Пример''': '''''Обработка списка файлов в цикле for.'''''
<source lang="bash">
#!/bin/bash
# list-glob.sh: Создание список файлов в цикле for с использованием
# операции подстановки имён файлов ("globbing").
echo
for file in *
do
ls -l "$file" # Список всех файлов в $PWD (текущем каталоге).
# Напоминаю, что символу "*" соответствует любое имя файла,
# однако, в операциях подстановки имён файлов ("globbing"),
# имеются исключения — имена файлов, начинающиеся с точки.
# Если в каталоге нет ни одного файла, соответствующего шаблону,
# то за имя файла принимается сам шаблон.
# Чтобы избежать этого, используйте ключ nullglob
# (shopt -s nullglob).
# Спасибо S.C.
done
echo; echo
for file in [jx]*
do
rm -f $file # Удаление файлов, начинающихся с "j" или "x" в $PWD.
echo "Удален файл \"$file\"".
done
echo
exit 0
</source>
Если [список] в цикле ''for'' не задан, то в качестве оного используется переменная '''$@''' — список аргументов командной строки.
 '''Пример''': '''''Цикл for без списка аргументов.'''''
<source lang="bash">
#!/bin/bash
# Попробуйте вызвать этот сценарий с аргументами и без них и посмотреть на результаты.
for a
do
echo -n "$a "
done # Список аргументов не задан, поэтому цикл работает с переменной '$@'
# (список аргументов командной строки, включая пробельные символы).
echo
exit 0
</source>
При создании списка аргументов, в цикле ''for'' допускается пользоваться подстановкой команд.
 '''Пример''': '''''Создание списка аргументов в цикле for с помощью операции подстановки команд.'''''
<source lang="bash">
#!/bin/bash
# Цикл for со [списком], созданным с помощью подстановки команд.
NUMBERS="9 7 3 8 37.53"
for number in `echo $NUMBERS` # for number in 9 7 3 8 37.53\
do
echo -n "$number "
done
echo
exit 0
</source>
Более сложный пример использования подстановки команд при создании списка аргументов цикла.
 '''Пример''': '''''grep для бинарных файлов.'''''
<source lang="bash">
#!/bin/bash
# bin-grep.sh: Поиск строк в двоичных файлах.
# замена "grep" для бинарных файлов.
# Аналогично команде "grep -a"
E_BADARGS=65
E_NOFILE=66if [ $# -ne 2 ]
then
echo "Порядок использования: `basename $0` string filename"
exit $E_BADARGS
fi

if [ ! -f "$2" ]
then
echo "Файл \"$2\" не найден."
exit $E_NOFILE
fi

for word in $( strings "$2" | grep "$1" )
# Инструкция "strings" возвращает список строк в двоичных файлах.
# Который затем передается по конвейеру команде "grep", для выполнения поиска.
do
echo $word
done
# Как указывает S.C., вышеприведённое объявление цикла for может быть упрощено
# strings "$2" | grep "$1" | tr -s "$IFS" '[\n*]'
# Попробуйте что нибудь подобное: "./bin-grep.sh mem /bin/ls"
exit 0
</source>
Ещё один пример.
 '''Пример''': '''''Список всех пользователей системы.'''''
<source lang="bash">
#!/bin/bash
# userlist.sh
PASSWORD_FILE=/etc/passwd
n=1 # Число пользователей
for name in $(awk 'BEGIN{FS=":"}{print $1}' < "$PASSWORD_FILE" )
# Разделитель полей = : ^^^^^^
# Вывод первого поля ^^^^^^^^
# Данные берутся из файла паролей ^^^^^^^^^^^^^^^^^
do
echo "Пользователь #$n = $name"
let "n += 1"
done
# Пользователь #1 = root
# Пользователь #2 = bin
# Пользователь #3 = daemon
# ...
# Пользователь #30 = bozo
exit 0
</source>
И заключительный пример использования подстановки команд при создании [списка].
 '''Пример''': '''''Проверка авторства всех бинарных файлов в текущем каталоге.'''''
<source lang="bash">
#!/bin/bash
# findstring.sh:
# Поиск заданной строки в двоичном файле.
directory=/usr/local/bin/
fstring="Free Software Foundation" # Поиск файлов от FSF.
for file in $( find $directory -type f -name '*' | sort )
do
strings -f $file | grep "$fstring" | sed -e "s%$directory%%"
# Команде "sed" передается выражение (ключ -e),
# для того, чтобы изменить обычный разделитель "/" строки поиска и строки замены
# поскольку "/" - один из отфильтровываемых символов.
# Использование такого символа порождает сообщение об ошибке (попробуйте).
done
exit 0
# Упражнение:
# ---------------
# Измените сценарий таким образом, чтобы он брал
# $directory и $fstring из командной строки.
</source>
Результат работы цикла ''for'' может передаваться другим командам по конвейеру.
 '''Пример''': '''''Список символических ссылок в каталоге.'''''
<source lang="bash">
#!/bin/bash
# symlinks.sh: Список символических ссылок в каталоге.

directory=${1-`pwd`}
# По-умолчанию в текущем каталоге,
# Блок кода, который выполняет аналогичные действия.
# ----------------------------------------------------------
# ARGS=1 # Ожидается один аргумент командной строки.
# if [ $# -ne "$ARGS" ] # Если каталог поиска не задан...
# then
# directory=`pwd`
# текущий каталог
# else
# directory=$1
# fi
# ----------------------------------------------------------
echo "символические ссылки в каталоге \"$directory\""
for file in "$( find $directory -type l )" # -type l = символические ссылки
do
echo "$file"
done | sort # В противном случае получится неотсортированный список.
# Как отмечает Dominik 'Aeneas' Schnitzer,
# в случае отсутствия кавычек для $( find $directory -type l )
# сценарий "подавится" именами файлов, содержащими пробелы.
exit 0
</source>
Вывод цикла может быть перенаправлен с ''stdout'' в файл, ниже приводится немного модифицированный вариант предыдущего примера, демонстрирующий эту возможность.
 '''Пример''': '''''Список символических ссылок в каталоге, сохраняемый в файле.'''''
<source lang="bash">
#!/bin/bash
# symlinks.sh: Список символических ссылок в каталоге.
OUTFILE=symlinks.list
# файл со списком
directory=${1-`pwd`}
# По-умолчанию — текущий каталог,
echo "символические ссылки в каталоге \"$directory\"" > "$OUTFILE"
echo "---------------------------" >> "$OUTFILE"
for file in "$( find $directory -type l )" # -type l = символические ссылки
do
echo "$file"
done | sort >> "$OUTFILE" # перенаправление вывода
# ^^^^^^^^^^^^^ в файл.
exit 0
</source>
Оператор цикла ''for'' имеет и альтернативный синтаксис записи — очень похожий на синтаксис оператора ''for'' в языке C. Для этого используются двойные круглые скобки.
 '''Пример''': '''''C-подобный синтаксис оператора цикла for.'''''
<source lang="bash">
#!/bin/bash
# Два варианта оформления цикла.
echo
# Стандартный синтаксис.
for a in 1 2 3 4 5 6 7 8 9 10
do
echo -n "$a "
done
echo; echo
# +==========================================+
# А теперь C-подобный синтаксис.
LIMIT=10
for ((a=1; a <= LIMIT ; a++)) # Двойные круглые скобки и "LIMIT" без "$".
do
echo -n "$a "
done # Конструкция заимствована из 'ksh93'.
echo; echo
# +=========================================================================+
# Попробуем и C-шный оператор "запятая".
for ((a=1, b=1; a <= LIMIT ; a++, b++)) # Запятая разделяет две операции, которые выполняются совместно.
do
echo -n "$a-$b "
done
echo; echo
exit 0
</source>
А сейчас пример сценария, который может найти "реальное" применение.
 '''Пример''': '''''Работа с командой efax в пакетном режиме.'''''
<source lang="bash">
#!/bin/bash
EXPECTED_ARGS=2
E_BADARGS=65
if [ $# -ne $EXPECTED_ARGS ]
# Проверка наличия аргументов командной строки.
then
echo "Порядок использования: `basename $0` phone# text-file"
exit $E_BADARGS
fi

if [ ! -f "$2" ]
then
echo "Файл $2 не является текстовым файлом"
exit $E_BADARGS
fi
fax make $2 # Создать fax-файлы из текстовых файлов.
for file in $(ls $2.0*) # Все файлы, получившиеся в результате преобразования.
# Используется шаблонный символ в списке.
do
fil="$fil $file"
done
efax -d /dev/ttyS3 -o1 -t "T$1" $fil # отправить.
# Как указывает S.C., в цикл for может быть вставлена сама команда отправки в виде:
# efax -d /dev/ttyS3 -o1 -t "T$1" $2.0*
# но это не так поучительно [;-)].
exit 0
</source>
 
<big>'''Циклы while'''</big> 
<big>'''while'''</big> 
Оператор ''while'' проверяет условие перед началом каждой итерации и если условие истинно(если код возврата равен 0), то управление передаётся в тело цикла. В отличие от циклов ''for'', циклы ''while'' используются в тех случаях, когда количество итераций заранее не известно.
<source lang="bash">
while [condition]
do
command...
done
</source>
Как и в случае с циклами ''for/in'', при размещении ключевого слова ''do'' в одной строке с объявлением цикла, необходимо вставлять символ ";" перед ''do''.
<source lang="bash"> while [condition] ; do</source>
Обратите внимание: в отдельных случаях, таких как использование конструкции ''getopts'' совместно с оператором ''while'', синтаксис несколько отличается от приводимого здесь.
 '''Пример''': '''''Простой цикл while.'''''
<source lang="bash">
#!/bin/bash
var0=0
LIMIT=10
while [ "$var0" -lt "$LIMIT" ]
do
echo -n "$var0 " # -n подавляет перевод строки.
var0=`expr $var0 + 1` # допускается var0=$(($var0+1)).
done
echo
exit 0
</source>
 '''Пример''': '''''Другой пример цикла while.'''''
<source lang="bash">
#!/bin/bash
echo
while [ "$var1" != "end" ] # возможна замена на while test "$var1" != "end"
do
echo "Введите значение переменной #1 (end - выход) "
read var1 # Конструкция 'read $var1' недопустима (почему?).
echo "переменная #1 = $var1" # кавычки обязательны, потому что имеется символ "#".
# Если введено слово 'end', то оно тоже выводится на экран.
# потому, что проверка переменной выполняется в начале итерации (перед вводом).
echo
done
exit 0
</source>
Оператор ''while'' может иметь несколько условий. Но только последнее из них определяет возможность продолжения цикла. В этом случае синтаксис оператора цикла должен быть несколько иным.
 '''Пример''': '''''Цикл while с несколькими условиями.'''''
<source lang="bash">
#!/bin/bash
var1=unset
previous=$var1
while echo "предыдущее значение = $previous"
echo
previous=$var1 # запомнить предыдущее значение
[ "$var1" != end ]
# В операторе "while" присутствуют 4 условия, но только последнее управляет циклом.
# *последнее* условие - единственное, которое вычисляется.
do
echo "Введите значение переменной #1 (end - выход) "
read var1
echo "текущее значение = $var1"
done
# попробуйте самостоятельно разобраться в сценарии works.
exit 0
</source>
Как и в случае с ''for'', цикл ''while'' может быть записан в C-подобной нотации, с использованием двойных круглых скобок.
 '''Пример''': '''''C-подобный синтаксис оформления цикла while.'''''
<source lang="bash">
#!/bin/bash
# wh-loopc.sh: Цикл перебора от 1 до 10.
LIMIT=10
a=1
while [ "$a" -le $LIMIT ]
do
echo -n "$a "
let "a+=1"
done # Пока ничего особенного.
echo; echo
# +=================================================================+
# А теперь оформим в стиле языка C.
((a = 1)) # a=1
# Двойные скобки допускают наличие лишних пробелов в выражениях.
while (( a <= LIMIT )) # В двойных скобках символ "$" перед переменными опускается.
do
echo -n "$a "
((a += 1)) # let "a+=1"
# Двойные скобки позволяют наращивание переменной в стиле языка C.
done
echo
# Теперь, программисты, пишущие на C, могут чувствовать себя в Bash как дома.
exit 0
</source>
Стандартное устройство ввода ''stdin'', для цикла ''while'', можно перенаправить на файл с помощью команды перенаправления '''''<''''' в конце цикла. 
<big>'''Циклы until'''</big> 
<big>'''until'''</big> 
Оператор цикла ''until'' проверяет условие в начале каждой итерации, но в отличие от ''while'' итерация возможна только в том случае, если условие ложно.
<source lang="bash">
until [condition-is-true]
do
command...
done
</source>
Обратите внимание: оператор ''until'' проверяет условие завершения цикла '''''ПЕРЕД''''' очередной итерацией, а не после, как это принято в некоторых языках программирования.
Как и в случае с циклами ''for/in'', при размещении ключевого слова ''do'' в одной строке с объявлением цикла, необходимо вставлять символ ";" перед ''do''.
<source lang="bash">until [condition-is-true] ; do</source>
 '''Пример''': '''''Цикл until.'''''
<source lang="bash">
#!/bin/bash
until [ "$var1" = end ] # Проверка условия производится в начале итерации.
do
echo "Введите значение переменной #1 "
echo "(end - выход)"
read var1
echo "значение переменной #1 = $var1"
done
exit 0
</source>

=== Вложенные циклы ===
Цикл называется вложенным, если он размещается внутри другого цикла. На первом проходе, внешний цикл вызывает внутренний, который исполняется до своего завершения, после чего управление передаётся в тело внешнего цикла. На втором проходе внешний цикл опять вызывает внутренний. И так до тех пор, пока не завершится внешний цикл. Само собой, как внешний, так и внутренний циклы могут быть прерваны командой ''break''.
 '''Пример''': '''''Вложенный цикл'''''
<source lang="bash">
#!/bin/bash
# Вложенные циклы "for".
outer=1 # Счетчик внешнего цикла.
# Начало внешнего цикла.
for a in 1 2 3 4 5
do
echo "Итерация #$outer внешнего цикла."
echo "---------------------"
inner=1 # Сброс счетчика вложенного цикла.
# Начало вложенного цикла.
for b in 1 2 3 4 5
do
echo "Итерация #$inner вложенного цикла."
let "inner+=1" # Увеличить счетчик итераций вложенного цикла.
done
# Конец вложенного цикла.
let "outer+=1" # Увеличить счетчик итераций внешнего цикла.
echo # Пустая строка для отделения итераций внешнего цикла.
done
# Конец внешнего цикла.
exit 0
</source>

=== Управление ходом выполнения цикла ===
<big>'''break, continue'''</big> 
Для управления ходом выполнения цикла служат команды ''break'' и ''continue''и точно соответствуют своим аналогам в других языках программирования. Команда ''break'' прерывает
исполнение цикла, в то время как ''continue'' передает управление в начало цикло, минуя все последующие команды в теле цикла.
 '''Пример''': '''''Команды break и continue в цикле.'''''
<source lang="bash">
#!/bin/bash
LIMIT=19 # Верхний предел
echo
echo "Печать чисел от 1 до 20 (исключая 3 и 11)."
a=0
while [ $a -le "$LIMIT" ]
do
a=$(($a+1))
if [ "$a" -eq 3 ] || [ "$a" -eq 11 ] # Исключить 3 и 11
then
continue # Переход в начало цикла.
fi
echo -n "$a "
done
# Упражнение:
# Почему число 20 тоже выводится?
echo; echo
echo Печать чисел от 1 до 20, но взгляните, что происходит после вывода числа 2
##################################################################
# Тот же цикл, только 'continue' заменено на 'break'.
a=0
while [ "$a" -le "$LIMIT" ]
do
a=$(($a+1))
if [ "$a" -gt 2 ]
then
break # Завершение работы цикла.
fi
echo -n "$a "
done
echo; echo; echo
exit 0
</source>
Команде ''break'' может быть передан необязательный параметр. Команда ''break'' без параметра прерывает тот цикл, в который она вставлена, а ''break N'' прерывает цикл, стоящий на N уровней выше (причем 1-й уровень — это уровень текущего цикла, прим. перев.).
 '''Пример''': '''''Прерывание многоуровневых циклов.'''''
<source lang="bash">
#!/bin/bash
# break-levels.sh: Прерывание циклов.
# "break N" прерывает исполнение цикла, стоящего на N уровней выше текущего.
for outerloop in 1 2 3 4 5
do
echo -n "Группа $outerloop: "
for innerloop in 1 2 3 4 5
do
echo -n "$innerloop "
if [ "$innerloop" -eq 3 ]
then
break # Попробуйте "break 2",
# тогда будут прерываться как вложенный, так и внешний циклы
fi
done
echo
done
echo
exit 0
</source>
Команда ''continue'', как и команда ''break'', может иметь необязательный параметр. В простейшем случае, команда ''continue'' передаёт управление в начало текущего цикла, а команда ''continue N'' прерывает исполнение текущего цикла и передаёт управление в начало внешнего цикла, отстоящего от текущего на N уровней (причем 1-й уровень — это уровень текущего цикла,прим. перев.).
 '''Пример''': '''''Передача управления в начало внешнего цикла.'''''
<source lang="bash">
#!/bin/bash
# Команда "continue N" передаёт управление в начало внешнего цикла, отстоящего от текущего на N уровней.
for outer in I II III IV V # внешний цикл
do
echo; echo -n "Группа $outer: "
for inner in 1 2 3 4 5 6 7 8 9 10 # вложенный цикл
do
if [ "$inner" -eq 7 ]
then
continue 2 # Передача управления в начало цикла 2-го уровня.
# попробуйте убрать параметр 2 команды "continue"
fi
echo -n "$inner " # 8 9 10 никогда не будут напечатаны.
done
done
echo; echo
# Упражнение:
# Подумайте, где реально можно использовать "continue N" в сценариях.
exit 0
</source>
 '''Пример''': '''''Живой пример использования "continue N".'''''
<source lang="bash">
# Albert Reiner привёл пример использования "continue N":
# ---------------------------------------------------------
# Допустим, у меня есть большое количество задач, обрабатывающие некоторые данные,
# которые хранятся в некоторых файлах, с именами, задаваемыми по шаблону,
# в заданном каталоге.
# Есть несколько машин, которым открыт доступ к этому каталогу
# и я хочу распределить обработку информации между машинами.
# тогда я обычно для каждой машины пишу нечто подобное:
while true
do
for n in .iso.*
do
[ "$n" = ".iso.opts" ] && continue
beta=${n#.iso.}
[ -r .Iso.$beta ] && continue
[ -r .lock.$beta ] && sleep 10 && continue
lockfile -r0 .lock.$beta || continue
echo -n "$beta: " `date`
run-isotherm $beta
date
ls -alF .Iso.$beta
[ -r .Iso.$beta ] && rm -f .lock.$beta
continue 2
done
break
done
# Конкретная реализация цикла, особенно sleep N, зависит от конкретных применений,
# но в общем случае он строится по такой схеме:
while true
do
for job in {шаблон}
do
{файл уже обработан или обрабатывается} && continue
{пометить файл как обрабатываемый, обработать, пометить как обработанный}
continue 2
done
break # Или что нибудь подобное `sleep 600', чтобы избежать завершения.
done
# Этот сценарий завершит работу после того как все данные будут обработаны
# (включая данные, которые поступили во время обработки). Использование
# соответствующих lock-файлов позволяет вести обработку на нескольких машинах
# одновременно, не производя дублирующих вычислений [которые, в моем случае,
# выполняются в течении нескольких часов, так что для меня это очень важно].
# Кроме того, поскольку поиск необработанных файлов всегда начинается с
# самого начала, можно задавать приоритеты в именах файлов. Конечно, можно
# обойтись и без `continue 2', но тогда придется ввести дополнительную
# проверку — действительно ли был обработан тот или иной файл
# (чтобы перейти к поиску следующего необработанного файла).
</source>
Конструкция ''continue N'' довольно сложна в понимании и применении, поэтому, вероятно лучше будет постараться избегать её использования.

=== Операторы выбора ===
Инструкции ''case'' и ''select'' технически не являются циклами, поскольку не предусматривают многократное исполнение блока кода. Однако, они, как и циклы, управляют ходом исполнения программы, в зависимости от начальных или конечных условий. 
<big>'''case (in) / esac'''</big> 
Конструкция ''case'' эквивалентна конструкции ''switch'' в языке C/C++. Она позволяет выполнять тот или иной участок кода, в зависимости от результатов проверки условий. Она является, своего рода, краткой формой записи большого количества операторов ''if/then/else'' и может быть неплохим инструментом при создании разного рода меню.
<source lang="bash">
case "$variable" in
"$condition1" )
command...
;;
"$condition2" )
command...
;;
esac
</source>
* Заключать переменные в кавычки необязательно, поскольку здесь не производится разбиения на отдельные слова.
* Каждая строка с условием должна завершаться правой (закрывающей)круглой скобкой — <big>''')'''</big>.
* Каждый блок команд, отрабатывающих по заданному условию, должен завершаться двумя символами точка-с-запятой — <big>''';;'''</big>.
* Блок ''case'' должен завершаться ключевым словом ''esac'' (''case'' записанное в обратном порядке).
 '''Пример''': '''''Использование case.'''''
<source lang="bash">
#!/bin/bash
echo; echo "Нажмите клавишу и затем клавишу Return."
read Keypress
case "$Keypress" in
[a-z] ) echo "буква в нижнем регистре";;
[A-Z] ) echo "Буква в верхнем регистре";;
[0-9] ) echo "Цифра";;
* ) echo "Знак пунктуации, пробел или что-то другое";;
esac # Допускается указывать диапазоны символов в [квадратных скобках].
# Упражнение:
# --------
# Сейчас сценарий считывает нажатую клавишу и завершается.
# Измените его так, чтобы сценарий продолжал отвечать на нажатия клавиш,
# но завершался бы только после ввода символа "X".
# Подсказка: заключите всё в цикл "while".
exit 0
</source>
 '''Пример''': '''''Создание меню с помощью case.'''''
<source lang="bash">
#!/bin/bash
# Грубый пример базы данных
clear # Очистка экрана
echo " Список"
echo " ------"
echo "Выберите интересующую Вас персону:"
echo
echo "[E]vans, Roland"
echo "[J]ones, Mildred"
echo "[S]mith, Julie"
echo "[Z]ane, Morris"
echo
read person
case "$person" in # Обратите внимание: переменная взята в кавычки.
"E" | "e" )
# Пользователь может ввести как заглавную, так и строчную букву.
echo
echo "Roland Evans"
echo "4321 Floppy Dr."
echo "Hardscrabble, CO 80753"
echo "(303) 734-9874"
echo "(303) 734-9892 fax"
echo "revans@zzy.net"
echo "Старый друг и партнер по бизнесу"
;;
# Обратите внимание: блок кода, анализирующий конкретный выбор, завершается
# двумя символами "точка-с-запятой".
"J" | "j" )
echo
echo "Mildred Jones"
echo "249 E. 7th St., Apt. 19"
echo "New York, NY 10009"
echo "(212) 533-2814"
echo "(212) 533-9972 fax"
echo "milliej@loisaida.com"
echo "Подружка"
echo "День рождения: 11 февраля"
;;
# Информация о Smith и Zane будет добавлена позднее.
* )
# Выбор по-умолчанию.
# "Пустой" ввод тоже обрабатывается здесь.
echo
echo "Нет данных."
;;
esac
echo
# Упражнение:
# --------
# Измените этот сценарий таким образом, чтобы он не завершал работу
# после вывода информации о персоне, а переходил на ожидание нового
# ввода от пользователя.
exit 0
</source>
Очень хороший пример использования ''case'' для анализа аргументов, переданных из командной строки.
<source lang="bash">
#! /bin/bash
case "$1" in
"") echo "Порядок использования: ${0##*/} <filename>"; exit 65;; # Параметры командной строки отсутствуют,
# или первый параметр — "пустой".
# Обратите внимание на ${0##*/} это подстановка параметра ${var##pattern}. В результате получается $0.
-*) FILENAME=./$1;; # Если имя файла (аргумент $1) начинается с "-",
# то заменить его на ./$1
# тогда параметр не будет восприниматься как ключ команды.
* ) FILENAME=$1;; # В противном случае — $1.
esac
</source>
 '''Пример''': '''''Оператор case допускает использовать подстановку команд вместо анализируемой переменной.'''''
<source lang="bash">
#!/bin/bash
# Подстановка команд в "case".
case $( arch ) in # команда "arch" возвращает строку, описывающую аппаратную апхитектуру.
i386 ) echo "Машина на базе процессора 80386";;
i486 ) echo "Машина на базе процессора 80486";;
i586 ) echo "Машина на базе процессора Pentium";;
i686 ) echo "Машина на базе процессора Pentium2 или выше";;
* ) echo "Машина на другом типе процессора";;
esac
exit 0
</source>
Оператор ''case'' допускает использование шаблонных конструкций.
 '''Пример''': '''''Простой пример сравнения строк.'''''
<source lang="bash">
#!/bin/bash
# match-string.sh: простое сравнение строк
match_string ()
{
MATCH=0
NOMATCH=90
PARAMS=2 # Функция требует два входных аргумента.
BAD_PARAMS=91
[ $# -eq $PARAMS ] || return $BAD_PARAMS
case "$1" in
"$2") return $MATCH;;
* ) return $NOMATCH;;
esac
}
a=one
b=two
c=three
d=two
match_string $a # неверное число аргументов
echo $? # 91
match_string $a $b # не равны
echo $? # 90
match_string $b $d # равны
echo $? # 0
exit 0
</source>
 '''Пример''': '''''Проверка ввода.'''''
<source lang="bash">
#!/bin/bash
# isalpha.sh: Использование "case" для анализа строк.
SUCCESS=0
FAILURE=-1
isalpha () # Проверка - является ли первый символ строки символом алфавита.
{
if [ -z "$1" ] # Вызов функции без входного аргумента?
then
return $FAILURE
fi

case "$1" in
[a-zA-Z] *) return $SUCCESS;; # Первый символ - буква?
* ) return $FAILURE;;
esac
} # Сравните с функцией "isalpha ()" в языке C.

isalpha2 () # Проверка - состоит ли вся строка только из символов алфавита.
{
[ $# -eq 1 ] || return $FAILURE

case $1 in
*[!a-zA-Z]*|"") return $FAILURE;;
*) return $SUCCESS;;
esac
}
isdigit () # Проверка - состоит ли вся строка только из цифр.
{ # Другими словами - является ли строка целым числом.
[ $# -eq 1 ] || return $FAILURE
case $1 in
*[!0-9]*|"") return $FAILURE;;
*) return $SUCCESS;;
esac
}

check_var () # Интерфейс к isalpha{
{
if isalpha "$@"
then
echo "\"$*\" начинается с алфавитного символа."
if isalpha2 "$@"
then # Дальнейшая проверка не имеет смысла, если первй символ не буква.
echo "\"$*\" содержит только алфавитные символы."
else
echo "\"$*\" содержит по меньшей мере один не алфавитный символ."
fi
else
echo "\"$*\" начинается с не алфавитного символа ."
# Если функция вызвана без входного параметра,
# то считается, что строка содержит "не алфавитной" символ.
fi
echo
}
digit_check () # Интерфейс к isdigit ().
{
if isdigit "$@"
then
echo "\"$*\" содержит только цифры [0 - 9]."
else
echo "\"$*\" содержит по меньшей мере один не цифровой символ."
fi
echo
}
a=23skidoo
b=H3llo
c=-What?
d=What?
e=`echo $b` # Подстановка команды.
f=AbcDef
g=27234
h=27a34
i=27.34
check_var $a
check_var $b
check_var $c
check_var $d
check_var $e
check_var $f
check_var # Вызов без параметра, что произойдет?
#
digit_check $g
digit_check $h
digit_check $i
exit 0 # Сценарий дополнен S.C.
# Упражнение:
# --------
# Напишите функцию 'isfloat ()', которая проверяла бы вещественные числа.
# Подсказка: Эта функция подобна функции 'isdigit ()',
# надо лишь добавить анализ наличия десятичной точки.
</source>
<big>'''select'''</big> 
Оператор select был заимствован из Korn Shell, и является еще одним инструментом,используемым при создании меню.
<source lang="bash">
select variable [in list]
do
command...
break
done
</source>
Этот оператор предлагает пользователю выбрать один из представленных вариантов.Примечательно, что ''select'' по-умолчанию использует в качестве приглашения к вводу (prompt)— ''PS3'' ('''#?'''), который легко изменить.
 '''Пример''': '''''Создание меню с помощью select.'''''
<source lang="bash">
#!/bin/bash
PS3='Выберите ваш любимый овощ: ' # строка приглашения к вводу (prompt)
echo
select vegetable in "бобы" "морковь" "картофель" "лук" "брюква"
do
echo
echo "Вы предпочитаете $vegetable."
echo ";-))"
echo
break # если 'break' убрать, то получится бесконечный цикл.
done
exit 0
</source>
Если в операторе '''select''' список ''in list'' не задан, то в качестве списка будет использоваться список аргументов ('''''$@'''''), передаваемый сценарию или функции.
Сравните это с поведением оператора цикла 
<source lang="bash">for variable [in list]</source>
в котором не задан список аргументов.
 '''Пример''': '''''Создание меню с помощью select в функции.'''''
<source lang="bash">
#!/bin/bash
PS3='Выберите ваш любимый овощ: '
echo
choice_of()
{
select vegetable # список выбора [in list] отсутствует, поэтому 'select' использует входные аргументы функции.
do
echo
echo "Вы предпочитаете $vegetable."
echo ";-))"
echo
break
done
}
choice_of бобы рис морковь редис томат шпинат
# $1 $2 $3 $4 $5 $6
# передача списка выбора в функцию choice_of()
exit 0
</source>

== Внутренние команды ==
'''''Внутренняя команда''''' — это '''команда''', которая встроена непосредственно в Bash. Команды делаются встроенными либо из соображений производительности — встроенные команды исполняются быстрее,чем внешние, которые, как правило, запускаются в дочернем процессе, либо из-за необходимости прямого доступа к внутренним структурам командного интерпретатора.
{| class="wikitable"
| Действие, когда какая либо команда или сама командная оболочка инициирует (порождает) новый подпроцесс, что бы выполнить какую-либо работу, называется ветвлением ('''forking''') процесса. Новый процесс называется "дочерним" (или "потомком"), а породивший его процесс — "родительским" (или "предком"). В результате и потомок и предок продолжают исполняться одновременно — параллельно друг другу. В общем случае, встроенные команды Bash, при исполнении внутри сценария, не порождают новый подпроцесс, в то время как вызов внешних команд, как правило, приводит к созданию нового подпроцесса.
|}
Внутренние команды могут иметь внешние аналоги. Например, внутренняя команда Bash — ''echo'' имеет внешний аналог ''/bin/echo'' и их поведение практически идентично.
<source lang="bash">
#!/bin/bash
echo "Эта строка выводится внутренней командой \"echo\"."
/bin/echo "А эта строка выводится внешней командой /bin/echo."
</source>
'''''Ключевое слово''''' ('''''keyword''''') — это зарезервированное слово, синтаксический элемент (''token'') или оператор. Ключевые слова имеют специальное назначение для командного интерпретатора, и фактически являются элементами синтаксиса языка командной оболочки. В качестве примера можно привести "for", "while", "do", "!", которые являются ключевыми (или зарезервированными) словами. Подобно встроенным командам, ключевые слова жёстко зашиты в Bash, но в отличие от встроенных команд, ключевые слова не являются командами как таковыми, хотя при этом могут являться их составной частью. 
<big>'''Ввод/вывод'''</big> 
<big>'''echo'''</big> 
Выводит (на ''stdout'') выражение или содержимое переменной.
<source lang="bash">
echo Hello
echo $a
</source>
Для вывода экранированных символов, '''echo''' требует наличие ключа ''-e''.
Обычно, команда '''echo''' выводит в конце символ перевода строки. Подавить вывод это символа можно ключом ''-n''. 
Команда '''echo''' может использоваться для передачи информации по конвейеру другим командам: 
<source lang="bash">
if echo "$VAR" | grep -q txt # if [[ $VAR = *txt* ]]
then
echo "$VAR содержит подстроку \"txt\""
fi
</source>
Кроме того, команда '''echo''', в комбинации с подстановкой команд может участвовать в операции присвоения значения переменной.
<source lang="bash">
a=`echo "HELLO" | tr A-Z a-z`
</source>
Следует запомнить, что команда '''echo `command`''' удалит все символы перевода строки, которые будут выведены командой ''`command`''. 
Переменная '''''$IFS''''' обычно содержит символ перевода строки ''\n'', как один из вариантов пробельного символа. Bash разобьёт вывод команды ''`command`'', по пробельным символам, на аргументы и передаст их команде '''echo''', которая выведет эти аргументы, разделённые пробелами.
<source lang="bash">
bash$ ls -l /usr/share/apps/kjezz/sounds
-rw-r--r-- 1 root root 1407 Nov 7 2000 reflect.au
-rw-r--r-- 1 root root 362 Nov 7 2000 seconds.au
bash$ echo `ls -l /usr/share/apps/kjezz/sounds`
total 40 -rw-r--r-- 1 root root 716 Nov 7 2000 reflect.au -rw-r--r-- 1 root root 362 Nov 7 2000 seconds.au
</source>
Это встроенная команда Bash и имеет внешний аналог '''''/bin/echo'''''.
<source lang="bash">
bash$ type -a echo
echo is a shell builtin
echo is /bin/echo
</source>
<big>'''printf'''</big> 
<big>'''printf'''</big> — команда форматированного вывода, расширенный вариант команды '''echo''' и ограниченный вариант библиотечной функции ''printf()'' в языке C, к тому же синтаксис их несколько отличается друг от друга. 
'''printf''' ''format-string''... ''parameter''... 
Это встроенная команда Bash. Имеет внешний аналог '''''/bin/printf''''' или '''''/usr/bin/printf'''''. За более подробной информацией обращайтесь к страницам справочного руководства ''man 1 printf'' по системным командам. 
<big>'''!'''</big>Старые версии Bash могут не поддерживать команду '''''printf'''''.
 '''Пример''': '''''printf в действии.'''''
<source lang="bash">
#!/bin/bash
# printf demo
# От переводчика:
# Считаю своим долгом напомнить, что в качестве разделителя дробной и целой
# частей в вещественных числах, может использоваться символ "запятая"
# (в русских локалях), поэтому данный сценарий может выдавать сообщение
# об ошибке (у меня так и произошло) при выводе числа PI.
# Тогда попробуйте заменить в определении числа PI десятичную точку
# на запятую — это должно помочь. ;-)
PI=3,14159265358979
DecimalConstant=31373
Message1="Поздравляю,"
Message2="Землянин."
echo
printf "Число пи с точностью до 2 знака после запятой = %1.2f" $PI
echo
printf "Число пи с точностью до 9 знака после запятой = %1.9f" $PI
# Даже округляет правильно.
printf "\n" # Перевод строки,
printf "Константа = \t%d\n" $DecimalConstant # Вставлен символ табуляции (\t)
printf "%s %s \n" $Message1 $Message2
echo
# ==========================================#
# Эмуляция функции 'sprintf' в языке C.
# Запись форматированной строки в переменную.
echo
Pi12=$(printf "%1.12f" $PI)
echo "Число пи с точностью до 12 знака после запятой = $Pi12"
Msg=`printf "%s %s \n" $Message1 $Message2`
echo $Msg; echo $Msg
exit 0
</source>
Одно из полезных применений команды '''''printf''''' — форматированный вывод сообщений об ошибках.
<source lang="bash">
E_BADDIR=65
var=nonexistent_directory
error()
{
printf "$@" >&2
# Форматированный вывод аргументов на stderr.
echo
exit $E_BADDIR
}
cd $var || error $"Невозможно перейти в каталог %s." "$var"
# Спасибо S.C.
</source>
<big>'''read'''</big> 
"Читает" значение переменной с устройства стандартного ввода — stdin, в интерактивном режиме это означает клавиатуру. Ключ ''-a'' позволяет записывать значения в массивы.
 '''Пример''': '''''Ввод значений переменных с помощью read.'''''
<source lang="bash">
#!/bin/bash
echo -n "Введите значение переменной 'var1': "
# Ключ -n подавляет вывод символа перевода строки.
read var1
# Обратите внимание — перед именем переменной отсутствует символ '$'.
echo "var1 = $var1"
echo
# Одной командой 'read' можно вводить несколько переменных.
echo -n "Введите значения для переменных 'var2' и 'var3' (через пробел или табуляцию): "
read var2 var3
echo "var2 = $var2 var3 = $var3"
# Если было введено значение только одной переменной, то вторая останется "пустой".
exit 0
</source>
Если команде '''''read''''' не была передано ни одной переменной, то ввод будет осуществлён в переменную '''''$REPLY'''''.
 '''Пример''': '''''Пример использования команды read без указания переменной для ввода.'''''
<source lang="bash">
#!/bin/bash
echo
# -------------------------- #
# Первый блок кода.
echo -n "Введите значение: "
read var
echo "\"var\" = "$var""
# Здесь нет ничего неожиданного.
# -------------------------- #
echo
echo -n "Введите другое значение: "
read # Команда 'read' употребляется без указания переменной для ввода,
# тем не менее...
# По-умолчанию ввод осуществляется в переменную $REPLY.
var="$REPLY"
echo "\"var\" = "$var""
# Эта часть сценария эквивалентна первому блоку, выделенному выше.
echo
exit 0
</source>
Обычно, при вводе в окне терминала с помощью команды '''''read''''', символ ''\'' служит для экранирования символа перевода строки. Ключ ''-r'' заставляет интерпретировать символ ''\'' как обычный символ.
 '''Пример''': '''''Ввод многострочного текста с помощью read.'''''
<source lang="bash">
#!/bin/bash
echo
echo "Введите строку, завершающуюся символом \\, и нажмите ENTER."
echo "Затем введите вторую строку, и снова нажмите ENTER."
read var1 # При чтении, символ "\" экранирует перевод строки.
# первая строка \
# вторая строка
echo "var1 = $var1"
# var1 = первая строка вторая строка
# После ввода каждой строки, завершающейся символом "\",
# вы можете продолжать ввод на другой строке.
echo; echo
echo "Введите другую строку, завершающуюся символом \\, и нажмите ENTER."
read -r var2 # Ключ -r заставляет команду "read" воспринимать "\"
# как обычный символ.
# первая строка \
echo "var2 = $var2"
# var2 = первая строка \
# Ввод данных прекращается сразу же после первого нажатия на клавишу ENTER.
echo
exit 0
</source>
Команда '''''read''''' имеет ряд очень любопытных опций, которые позволяют выводить подсказку — приглашение ко вводу (prompt), и даже читать данные не дожидаясь нажатия на клавишу ''ENTER''.
<source lang="bash">
# Чтение данных, не дожидаясь нажатия на клавишу ENTER.
read -s -n1 -p "Нажмите клавишу " keypress
echo; echo "Была нажата клавиша "\"$keypress\""."
# -s — подавляет эхо-вывод, т.е. ввод с клавиатуры не отображается на экране.
# -n N — ввод завершается автоматически, сразу же после ввода N-го символа.
# -p — задает вид строки подсказки - приглашения к вводу (prompt).
# Использование этих ключей немного осложняется тем, что они должны следовать в определенном порядке.
</source>
Ключ ''-n'', кроме всего прочего, позволяет команде '''''read''''' обнаруживать нажатие курсорных и некоторых других служебных клавиш.
 '''Пример''': '''''Обнаружение нажатия на курсорные клавиши.'''''
<source lang="bash">
#!/bin/bash
# arrow-detect.sh: Обнаружение нажатия на курсорные клавиши, и не только...
# Спасибо Sandro Magi за то что показал мне — как.
# --------------------------------------------
# Коды клавиш.
arrowup='\[A'
arrowdown='\[B'
arrowrt='\[C'
arrowleft='\[D'
insert='\[2'
delete='\[3'
# --------------------------------------------
SUCCESS=0
OTHER=65
echo -n "Нажмите на клавишу... "
# Может потребоваться нажать на ENTER, если была нажата клавиша
# не входящая в список выше.
read -n3 key # Прочитать 3 символа.
echo -n "$key" | grep "$arrowup" #Определение нажатой клавиши.
if [ "$?" -eq $SUCCESS ]
then
echo "Нажата клавиша \"."
exit $SUCCESS
fi
echo -n "$key" | grep "$arrowdown"
if [ "$?" -eq $SUCCESS ]
then
echo "Нажата клавиша \"
exit $SUCCESS
fi
echo -n "$key" | grep "$arrowrt"
if [ "$?" -eq $SUCCESS ]
then
echo "Нажата клавиша \"О\"."
exit $SUCCESS
fi
echo -n "$key" | grep "$arrowleft"
if [ "$?" -eq $SUCCESS ]
then
echo "Нажата клавиша \"."
exit $SUCCESS
fi
echo -n "$key" | grep "$insert"
if [ "$?" -eq $SUCCESS ]
then
echo "Нажата клавиша \"Insert\"."
exit $SUCCESS
fi
echo -n "$key" | grep "$delete"
if [ "$?" -eq $SUCCESS ]
then
echo "Нажата клавиша \"Delete\"."
exit $SUCCESS
fi
echo " Нажата какая-то другая клавиша."
exit $OTHER
# Упражнения:
# ---------
# 1) Упростите сценарий, заменив множество if-ов
# одной конструкцией 'case'.
# 2) Добавьте определение нажатий на клавиши "Home", "End", "PgUp" и "PgDn".
</source>
Ключ ''-t'' позволяет ограничивать время ожидания ввода командой '''''read''''' 
Команда '''''read''''' может считывать значения для переменных из файла, перенаправленного на ''stdin''. Если файл содержит не одну строку, то переменной будет присвоена только первая строка. Если команде '''''read''''' будет передано несколько переменных, то первая строка файла будет разбита, по пробелам, на несколько подстрок, каждая из которых будет записана в свою переменную. Будьте осторожны!
 '''Пример''': '''''Чтение командой read из файла через перенаправление.'''''
<source lang="bash">
read var1 <data-file
echo "var1 = $var1"
# Первая строка из "data-file" целиком записывается в переменную var1
read var2 var3 < data-file
echo "var2 = $var2 var3 = $var3"
# Обратите внимание!
# Поведение команды "read" далеко от ожидаемого!
# 1) Произошел возврат к началу файла.
# 2) Вместо того, чтобы последовательно читать строки из файла,
# по числу переменных, первая строка файла была разбита на подстроки,
# разделенные пробелами, которые и были записаны в переменные.
# 3) В последнюю переменную была записана вся оставшаяся часть строки.
# 4) Если команде "read" будет передано большее число переменных, чем подстрок
# в первой строке файла, то последние переменные останутся "пустыми".
echo "------------------------------------------------"
# Эта проблема легко разрешается с помощью цикла:
while read line
do
echo "$line"
done < data-file# Спасибо Heiner Steven за разъяснения.
echo "------------------------------------------------"
# Разбор строки, разделенной на поля
# Для задания разделителя полей, используется переменная $IFS,
echo "Список всех пользователей:"
OIFS=$IFS; IFS=: # В файле /etc/passwd, в качестве разделителя полей
# используется символ ":".
while read name passwd uid gid fullname ignore
do
echo "$name ($fullname)"
done < /etc/passwd # перенаправление ввода.
IFS=$OIFS # Восстановление предыдущего состояния переменной $
# Эту часть кода написал Heiner Steven.
# Если переменная $IFS устанавливается внутри цикла,
# то отпадает необходимость сохранения её первоначального значения
# во временной переменной.
# Спасибо Dim Segebart за разъяснения.
echo "------------------------------------------------"
echo "Список всех пользователей:"
while IFS=: read name passwd uid gid fullname ignore
do
echo "$name ($fullname)"
done < /etc/passwd # перенаправление ввода.
echo
echo "Значение переменной \$IFS осталось прежним: $IFS"
exit 0
</source>
Передача информации, выводимой командой '''''echo''''', по конвейеру команде '''''read''''', будет вызывать ошибку. Тем не менее, передача данных по конвейеру от [[cat]], кажется срабатывает. 
<source lang="bash">
cat file1 file2 |
while read line
do
echo $line
done
</source>
Не смотря на это, как указывает Bjon Eriksson: 

 '''Пример''': '''''Проблемы чтения данных из канала (конвейера).'''''
<source lang="bash">
#!/bin/sh
# readpipe.sh
# Этот сценарий предоставил Bjon Eriksson.
last="(null)"
cat $0 |
while read line
do
echo "{$line}"
last=$line
done
printf "\nКонец, последняя строка:$last\n"
exit 0 # Конец сценария.
</source>
Далее следует результат (частично) работы сценария. 
./readpipe.sh
{#!/bin/sh}
{last="(null)"}
{cat $0 |}
{while read line}
{do}
{echo "{$line}"}
{last=$line}
{done}
{printf "nКонец, последняя строка:$last\n"}
Конец, последняя строка:(null)
Переменная (last) инициализируется в подоболочке, поэтому она оказывается не инициализированной за его пределами.

<big>'''Файловая система'''</big> 
<big>'''cd'''</big> 
Уже знакомая нам команда [[cd — Команда смены директории|cd]], изменяющая текущий каталог, может быть использована в случаях, когда некоторую команду необходимо запустить только находясь в определённом каталоге.
<source lang="bash">(cd /source/directory && tar cf - . ) | (cd /dest/directory && tar xpvf -)</source>
Команда [[cd — Команда смены директории|cd]] с ключом ''-P\'' (''physical'') игнорирует символические ссылки. Команда "cd -" выполняет переход в каталог $OLDPWD</blue> — предыдущий рабочий каталог. Неожиданным образом выполняется команда [[cd — Команда смены директории|cd]], если ей передать, в качестве каталога назначения, два слэша.
<source lang="bash">
bash$ cd //
bash$ pwd
//
</source>
Само собой разумеется, это должен был бы быть каталог ''/''. Эта проблема наблюдается как в командной строке, так и в сценариях. 
 <big>'''pwd'''</big> 
Выводит название текущего рабочего каталога (Print Working Directory). Кроме того, имя текущего каталога хранится во внутренней переменной $PWD. 
 <big>'''pushd,popd,dirs'''</big> 
Этот набор команд является составной частью механизма "закладок" на каталоги и позволяет перемещаться по каталогам вперед и назад в заданном порядке. Для хранения имён каталогов используется стек (LIFO — "последний вошёл, первый вышел"). 
'''''pushd''''' ''dir-name'' — помещает имя текущего каталога в стек и осуществляет переход в каталог ''dir-name''. 
'''''popd''''' — выталкивает, находящееся на вершине стека, имя каталога и одновременно осуществляет переход в каталог, оказавшийся на вершине стека. 
'''''dirs''''' — выводит содержимое стека каталогов (сравните с переменной $DIRSTACK). В случае успеха, обе команды — '''''pushd''''' и '''''popd''''' автоматически вызывают '''''dirs'''''. 
Эти команды могут оказаться весьма полезными, когда в сценарии нужно производить частую смену каталогов, но при этом не хочется жестко "зашивать" имена каталогов. Обратите внимание: содержимое стека каталогов постоянно хранится в переменной-массиве - $DIRSTACK.
 '''Пример''': '''''Смена текущего каталога.'''''
<source lang="bash">
#!/bin/bash
dir1=/usr/local
dir2=/var/spool
pushd $dir1 # Команда 'dirs' будет вызвана автоматически (на stdout будет выведено содержимое стека).
echo "Выполнен переход в каталог `pwd`." # Обратные одиночные кавычки.
# Теперь можно выполнить какие либо действия в каталоге 'dir1'.
pushd $dir2
echo "Выполнен переход в каталог `pwd`."
# Теперь можно выполнить какие либо действия в каталоге 'dir2'.
echo "На вершине стека находится: $DIRSTACK."
popd
echo "Возврат в каталог `pwd`."
# Теперь можно выполнить какие либо действия в каталоге 'dir1'.
popd
echo "Возврат в первоначальный рабочий каталог `pwd`."
exit 0
</source>

<big>'''Переменные'''</big> 
<big>'''let'''</big> 
Команда '''''let''''' производит арифметические операции над переменными. В большинстве случаев, её можно считать упрощенным вариантом команды '''''expr'''''.
 '''Пример''': '''''Команда let, арифметические операции.'''''
<source lang="bash">
#!/bin/bash
echo
let a=11 # То же, что и 'a=11'
let a=a+5 # Эквивалентно "a = a + 5"
# (Двойные кавычки и дополнительные пробелы делают код более удобочитаемым)
echo "11 + 5 = $a"

let "a <<= 3" # Эквивалентно let "a = a << 3"
echo "\"\$a\" (=16) после сдвига влево на 3 разряда = $a"

let "a /= 4" # Эквивалентно let "a = a / 4"
echo "128 / 4 = $a"

let "a -= 5" # Эквивалентно let "a = a - 5"
echo "32 - 5 = $a"

let "a = a * 10" # Эквивалентно let "a = a * 10"
echo "27 * 10 = $a"

let "a %= 8" # Эквивалентно let "a = a % 8"
echo "270 mod 8 = $a (270 / 8 = 33, остаток = $a)"

echo
exit 0
</source> 
<big>'''eval'''</big> 
'''''eval''''' ''arg1'' [''arg2''] ... [''argN''] 
Транслирует список аргументов, из списка, в команды.
 '''Пример''': '''''Демонстрация команды eval.'''''
<source lang="bash">
#!/bin/bash
y=`eval ls -l` # Подобно y=`ls -l`
echo $y # но символы перевода строки не выводятся, поскольку имя переменной не в кавычках.
echo
echo "$y" # Если имя переменной записать в кавычках — символы перевода строки сохраняются.
echo; echo
y=`eval df` # Аналогично y=`df`
# Когда производится подавление вывода символов LF (перевод строки), то анализ
# результатов различными утилитами, такими как awk, можно сделать проще.
exit 0
</source>
 '''Пример''': '''''Принудительное завершение сеанса.'''''
<source lang="bash">
#!/bin/bash
y=`eval ps ax | sed -n '/ppp/p' | awk '{ print $1 }'`
# Выяснить PID процесса 'ppp'.
kill -9 $y # "Прихлопнуть" его
# Предыдущие строки можно заменить одной строкой
# kill -9 `ps ax | awk '/ppp/ { print $1 }'
chmod 666 /dev/ttyS3 # Завершённый, по сигналу SIGKILL, ppp изменяет права доступа
# к последовательному порту. Вернуть их в первоначальное состояние.
rm /var/lock/LCK..ttyS3 # Удалить lock-файл последовательного порта.
exit 0
</source>
 '''Пример''': '''''Шифрование по алгоритму "rot13".'''''
<source lang="bash">
#!/bin/bash
# Реализация алгоритма шифрования "rot13" с помощью 'eval'.
# Сравните со сценарием "rot13.sh".
setvar_rot_13() # Криптование по алгоритму "rot13"
{
local varname=$1 varvalue=$2
eval $varname='$(echo "$varvalue" | tr a-z n-za-m)'
}
setvar_rot_13 var "foobar" # Пропустить слово "foobar" через rot13.
echo $var # sbbone
echo $var | tr a-z n-za-m # foobar
# Расшифровывание.
# Пример предоставил Stephane Chazelas.
exit 0
</source>
Rory Winston представил следующий пример, как образец практического использования команды '''''eval'''''.
 '''Пример''': '''''Замена имени переменной на её значение, в исходном тексте программы на языке Perl, с помощью eval.'''''
<source lang="perl">
В программе "test.pl", на языке Perl:
...
my $WEBROOT = <WEBROOT_PATH>;
...
Эта попытка подстановки значения переменной вместо её имени:
$export WEBROOT_PATH=/usr/local/webroot
$sed 's/<WEBROOT_PATH>/$WEBROOT_PATH/' < test.pl > out
даст такой результат:
my $WEBROOT = $WEBROOT_PATH;
Тем не менее:
$export WEBROOT_PATH=/usr/local/webroot
$eval sed 's/<WEBROOT_PATH>/$WEBROOT_PATH/' < test.pl > out
# ====
Этот вариант дал желаемый результат — имя переменной, в тексте программы,
благополучно было заменено на её значение:
my $WEBROOT = /usr/local/webroot
</source>
Команда '''''eval''''' может быть небезопасна. Если существует приемлемая альтернатива, то желательно воздерживаться от использования '''''eval'''''. Так, '''''eval''''' ''$COMMANDS'' исполняет код, который записан в переменную ''COMMANDS'', которая, в свою очередь, может содержать весьма неприятные сюрпризы, например '''rm -rf *'''. Использование команды '''''eval''''', для исполнения кода неизвестного происхождения, крайне опасно! 
<big>'''set'''</big> 
Команда '''''set''''' изменяет значения внутренних переменных сценария. Она может использоваться для переключения опций (ключей, флагов), определяющих поведение скрипта. Ещё одно применение — сброс/установка позиционных параметров (аргументов), значения которых будут восприняты как результат работы команды ('''''set `command`''''').
 '''Пример''': '''''Установка значений аргументов с помощью команды set.'''''
<source lang="bash">
#!/bin/bash
# script "set-test"
# Вызовите сценарий с тремя аргументами командной строки,
# например: "./set-test one two three".
echo
echo "Аргументы перед вызовом set \`uname -a\` :"
echo "Аргумент #1 = $1"
echo "Аргумент #2 = $2"
echo "Аргумент #3 = $3"
set `uname -a` # Изменение аргументов
# значения которых берутся из результата работы `uname -a`
echo $_
echo "Аргументы после вызова set \`uname -a\` :"
# $1, $2, $3 и т.д. будут переустановлены в соответствии с выводом
# команды `uname -a`
echo "Поле #1 'uname -a' = $1"
echo "Поле #2 'uname -a' = $2"
echo "Поле #3 'uname -a' = $3"
echo ---
echo $_ # ---
echo
exit 0
</source>
Вызов '''''set''''' без параметров просто выводит список инициализированных переменных окружения.
<source lang="bash">
bash$ set
AUTHORCOPY=/home/bozo/posts
BASH=/bin/bash
BASH_VERSION=$'2.05.8(1)-release'
...
XAUTHORITY=/home/bozo/.Xauthority
_=/etc/bashrc
variable22=abc
variable23=xzy
</source>
Если команда '''''set''''' используется с ключом "--", после которого следует переменная, то значение переменной переносится в позиционные параметры (аргументы). Если имя переменной отсутствует, то эта команда приводит к сбросу позиционных параметров.
 '''Пример''': '''''Изменение значений позиционных параметров (аргументов).'''''
<source lang="bash">
#!/bin/bash
variable="one two three four five"
set -- $variable
# Значения позиционных параметров берутся из "$variable".
first_param=$1
second_param=$2
shift; shift # сдвиг двух первых параметров.
remaining_params="$*"
echo
echo "первый параметр = $first_param" # one
echo "второй параметр = $second_param" # two
echo "остальные параметры = $remaining_params" # three four five
echo; echo
# Снова.
set -- $variable
first_param=$1
second_param=$2
echo "первый параметр = $first_param" # one
echo "второй параметр = $second_param" # two

# ======================================================

set --
# Позиционные параметры сбрасываются, если не задано имя переменной.

first_param=$1
second_param=$2
echo "первый параметр = $first_param" # (пустое значение)
echo "второй параметр = $second_param" # (пустое значение)

exit 0
</source> 
<big>'''unset'''</big> 
Команда '''''unset''''' удаляет переменную, фактически — устанавливает её значение в ''null''. Обратите внимание: эта команда не может сбрасывать позиционные параметры (аргументы)!
<source lang="bash">
bash$ unset PATH
bash$ echo $PATH

bash$
</source>

 '''Пример''': '''''"Сброс" переменной.'''''
<source lang="bash">
#!/bin/bash
# unset.sh: Сброс переменной.
variable=hello # Инициализация.
echo "variable = $variable"
unset variable # Сброс.
# Тот же эффект даёт variable=
echo "(unset) variable = $variable" # $variable = null.
exit 0
</source> 
<big>'''export'''</big> 
Команда '''export''' экспортирует переменную, делая её доступной дочерним процессам. К сожалению, невозможно экспортировать переменную родительскому процессу. В качестве примера использования команды '''export''' можно привести ''сценарии инициализации системы'', вызываемые в процессе загрузки, которые инициализируют и экспортируют ''переменные окружения'', делая их доступными для пользовательских процессов.
 '''Пример''': '''''Передача переменных во вложенный сценарий awk, с помощью export.'''''
<source lang="bash">
#!/bin/bash
# Ещё одна версия сценария "column totaler" (col-totaler.sh)
# который суммирует заданную колонку (чисел) в заданном файле.
# Здесь используются переменные окружения, которые передаются сценарию 'awk'.
ARGS=2
E_WRONGARGS=65
if [ $# -ne "$ARGS" ] # Проверка количества входных аргументов.
then
echo "Порядок использования: `basename $0` filename column-number"
exit $E_WRONGARGS
fi
filename=$1
column_number=$2
#===== До этой строки идентично первоначальному варианту сценария =====#
export column_number
# Экспорт номера столбца.
# Начало awk-сценария.
# ------------------------------------------------
awk '{ total += $ENVIRON["column_number"]
}
END { print total }' $filename
# ------------------------------------------------
# Конец awk-сценария.
# Спасибо Stephane Chazelas.
exit 0
</source>
Допускается объединение инициализации и экспорта переменной в одну инструкцию: '''''export var1=xxx'''''. 
Однако, как заметил ''Greg Keraunen'', в некоторых ситуациях такая комбинация может давать иной результат, нежели раздельная инициализация и экспорт.
<source lang="bash">
bash$ export var=(a b); echo ${var[0]}
(a b)
bash$ var=(a b); export var; echo ${var[0]}
a
</source> 
<big>'''declare,typeset'''</big> 
Команды ''declare'' и ''typeset'' задают и/или накладывают ограничения на переменные. 
<big>'''readonly'''</big> 
То же самое, что и '''''declare -r''''', делает переменную доступной только для чтения, т.е. переменная становится подобна константе. При попытке изменить значение такой переменной выводится сообщение об ошибке. Эта команда может расцениваться как квалификатор типа ''const'' в языке ''C''. 
<big>'''getopts'''</big> 
Мощный инструмент, используемый для разбора аргументов, передаваемых сценарию из командной строки. Это встроенная команда Bash, но имеется и её "внешний" аналог '''''/usr/bin/getopt''''', а так же программистам, пишущим на ''C'', хорошо знакома похожая библиотечная функция ''getopt''. Она позволяет обрабатывать серии опций, объединённых в один аргумент и дополнительные аргументы, передаваемые сценарию (например, ''scriptname -abc -e/usr/local''). 
С командой '''''getopts''''' очень тесно взаимосвязаны скрытые переменные. ''$OPTIND'' — указатель на аргумент (OPTion INDex) и ''$OPTARG'' (OPTion ARGument) — дополнительный аргумент опции. Символ двоеточия, следующий за именем опции, указывает на то, что она имеет дополнительный аргумент. 
Обычно '''''getopts''''' упаковывается в цикл ''while'', в каждом проходе цикла извлекается очередная опция и её аргумент (если он имеется), обрабатывается, затем уменьшается на 1 скрытая переменная ''$OPTIND'' и выполняется переход к началу новой итерации.
# Опциям (ключам), передаваемым в сценарий из командной строки, должен предшествовать символ "минус" (-) или "плюс" (+). Этот префикс (- или +) позволяет '''''getopts''''' отличать опции (ключи) от прочих аргументов. Фактически, '''''getopts''''' не будет обрабатывать аргументы, если им не предшествует символ - или +, выделение опций будет прекращено как только встретится первый аргумент.
# Типичная конструкция цикла ''while'' с '''''getopts''''' несколько отличается от стандартной из-за отсутствия квадратных скобок, проверяющих условие продолжения цикла.
# Пример '''''getopts''''', заменившей не рекомендуемую к использованию, внешнюю команду '''''getopt'''''.
<source lang="bash">
while getopts ":abcde:fg" Option
# Начальное объявление цикла анализа опций.
# a, b, c, d, e, f, g -- это возможные опции (ключи).
# Символ : после опции 'e' указывает на то, что с данной опцией может идти
# дополнительный аргумент.
do
case $Option in
a ) # Действия, предусмотренные опцией 'a'.
b ) # Действия, предусмотренные опцией 'b'.
...
e) # Действия, предусмотренные опцией 'e', а так же необходимо обработать $OPTARG,
# в которой находится дополнительный аргумент этой опции.
...
g ) # Действия, предусмотренные опцией 'g'.
esac
done
shift $(($OPTIND - 1))
# Перейти к следующей опции.
# Всё не так сложно, как может показаться ;-)
</source>

 '''Пример''': '''''Приём опций/аргументов, передаваемых сценарию, с помощью getopts.'''''
<source lang="bash">
#!/bin/bash
# ex33.sh
# Обработка опций командной строки с помощью 'getopts'.
# Попробуйте вызвать этот сценарий как:
# 'scriptname -mn'
# 'scriptname -oq qOption' (qOption может быть любой произвольной строкой.)
# 'scriptname -qXXX -r'
# 'scriptname -qr' - Неожиданный результат: "r" будет воспринят как дополнительный аргумент опции "q"
# 'scriptname -q -r' - То же самое, что и выше
# Если опция ожидает дополнительный аргумент ("flag:"), то следующий параметр
# в командной строке, будет воспринят как дополнительный аргумент этой опции.
NO_ARGS=0
E_OPTERROR=65
if [ $# -eq "$NO_ARGS" ] # Сценарий вызван без аргументов?
then
echo "Порядок использования: `basename $0` options (-mnopqrs)"
exit $E_OPTERROR # Если аргументы отсутствуют — выход с сообщением
# о порядке использования скрипта
fi
# Порядок использования: scriptname -options
# Обратите внимание: дефис (-) обязателенwhile getopts ":mnopq:rs" Option
do
echo $OPTIND
case $Option in
m ) echo "Сценарий #1: ключ -m-";;
n | o ) echo "Сценарий #2: ключ -$Option-";;
p ) echo "Сценарий #3: ключ -p-";;
q ) echo "Сценарий #4: ключ -q-, с аргументом \"$OPTARG\"";;
# Обратите внимание: с ключом 'q' должен передаваться дополнительный аргумент,
# в противном случае отработает выбор "по-умолчанию".
r | s ) echo "Сценарий #5: ключ -$Option-"'';;
* ) echo "Выбран недопустимый ключ.";; # ПО-УМОЛЧАНИЮ
esac
done
shift $(($OPTIND - 1))
# Переход к очередному параметру командной строки.
exit 0
</source>
<big>'''Управление сценарием'''</big> 
<big>'''source, .(точка)'''</big> 
Когда эта команда вызывается из командной строки, то это приводит к запуску указанного сценария. Внутри сценария, команда ''source'' '''file-name''' загружает файл '''file-name'''. Таким образом она очень напоминает директиву препроцессора языка C/C++ — "#include". Может найти применение в ситуациях, когда несколько сценариев пользуются одним файлом с данными или библиотекой функций.
 '''Пример''': '''''"Подключение" внешнего файла.'''''
<source lang="bash">
#!/bin/bash
. data-file # Загрузка файла с данными.
# Тот же эффект даёт "source data-file", но этот вариант более переносим.
# Файл "data-file" должен находиться в текущем каталоге,
# т.к. путь к нему не указан.
# Теперь, выведем некоторые переменные из этого файла.
echo "variable1 (из data-file) = $variable1"
echo "variable3 (из data-file) = $variable3"
let "sum = $variable2 + $variable4"
echo "Сумма variable2 + variable4 (из data-file) = $sum"
echo "message1 (из data-file): \"$message1\""
# Обратите внимание: кавычки экранированы
# print_message Вызвана функция вывода сообщений, находящаяся в data-file.
exit 0
</source>
Файл data-file для пример, представленного выше, должен находиться в том же каталоге.
<source lang="bash">
# Этот файл подключается к сценарию.
# Подключаемые файлы могут содержать об"явления переменных, функций и т.п.
# Загружаться может командой 'source' или '.' .
# Инициализация некоторых переменных.
variable1=22
variable2=474
variable3=5
variable4=97
message1="Привет! Как поживаете?"
message2="Досвидания!"
print_message ()
{
# Вывод сообщения переданного в эту функцию.
if [ -z "$1" ]
then
return 1
# Ошибка, если аргумент отсутствует.
fi
echo
until [ -z "$1" ]
do
# Цикл по всем аргументам функции.
echo -n "$1"
# Вывод аргумента с подавлением символа перевода строки.
echo -n " "
# Вставить пробел, для разделения выводимых аргументов.
shift
# Переход к следующему аргументу.
done
echo
return 0
}
</source>
Сценарий может подключить даже самого себя, только этому едва ли можно найти какое-либо практическое применение.
 '''Пример''': '''''Пример (бесполезный) сценария, который подключает себя самого.'''''
<source lang="bash">
#!/bin/bash
# self-source.sh: сценарий, который рекурсивно подключает себя самого."
# Из "Бестолковые трюки", том II.
MAXPASSCNT=100 # Максимальное количество проходов.
echo -n "$pass_count "
# На первом проходе выведет два пробела,
# т.к. $pass_count еще не инициализирована.

let "pass_count += 1"
# Операция инкремента не инициализированной переменной $pass_count
# на первом проходе вполне допустима.
# Этот прием срабатывает в Bash и pdksh, но,
# при переносе сценария в другие командные оболочки,
# он может оказаться неработоспособным или даже опасным.
# Лучшим выходом из положения, будет присвоить переменной $pass_count
# значение 0, если она не инициализирована.
while [ "$pass_count" -le $MAXPASSCNT ]
do
. $0 # "Подключение" самого себя.
# ./$0 (истинная рекурсия) в данной ситуации не сработает.
done
# Происходящее здесь фактически не является рекурсией как таковой,
# т.к. сценарий как бы "расширяет" себя самого
# (добавляя новый блок кода)
# на каждом проходе цикла 'while',
# командой 'source' в строке 22.
#
# Само собой разумеется, что первая строка (#!), вновь подключенного сценария,
# интерпретируется как комментарий, а не как начало нового сценария (sha-bang)
echo
exit 0 # The net effect is counting from 1 to 100.
# Very impressive.
# Упражнение:
# ----------
# Напишите сценарий, который использовал бы этот трюк для чего либо полезного.
</source> 
<big>'''exit'''</big> 
Безусловное завершение работы сценария. Команде '''''exit''''' можно передать целое число, которое будет возвращено вызывающему процессу как код завершения. Вообще, считается хорошей практикой завершать работу сценария, за исключением простейших случаев, командой ''exit 0'', чтобы проинформировать родительский процесс об успешном завершении.
Если сценарий завершается командой ''exit'' без аргументов, то в качестве кода завершения сценария принимается код завершения последней выполненной команды, не считая самой команды ''exit''.
<big>'''exec'''</big> 
Это встроенная команда интерпретатора ''shell'', заменяет текущий процесс новым процессом,запускаемым командой '''''exec'''''. Обычно, когда командный интерпретатор встречает эту команду, то он порождает дочерний процесс, чтобы исполнить команду. При использовании встроенной команды '''''exec''''', оболочка не порождает ещё один процесс, а заменяет текущий процесс другим. Для сценария это означает его завершение сразу после исполнения команды '''''exec'''''. По этой причине, если вам встретится '''''exec''''' в сценарии, то, скорее всего это будет последняя команда в сценарии.
 '''Пример''': '''''Команда exec.'''''
<source lang="bash">
#!/bin/bash
exec echo "Завершение \"$0\"." # Это завершение работы сценария.
# ----------------------------------
# Следующие ниже строки никогда не будут исполнены
echo "Эта строка никогда не будет выведена на экран."
exit 99 # Сценарий завершит работу не здесь.
# Проверьте код завершения сценария
# командой 'echo $?'.
# Он точно не будет равен 99.
</source>
 '''Пример''': '''''Сценарий, который запускает себя самого.'''''
<source lang="bash">
#!/bin/bash
# self-exec.sh
echo
echo "Эта строка в сценарии единственная, но она продолжает выводиться раз за разом."
echo "PID остался равным $$."
# Демонстрация того, что команда exec не порождает дочерний процесс.
echo "==================== Для завершения - нажмите Ctl-C ===================="
sleep 1
exec $0 # Запуск очередного экземпляра этого же сценария
# который замещает предыдущий.
echo "Эта строка никогда не будет выведена!" # Почему?
exit 0
</source>
Команда '''''exec''''' так же может использоваться для перенаправления. Так, команда ''exec < zzz-file'' заменит стандартное устройство ввода (''stdin'') файлом ''zzz-file''.
Ключ ''-exec'' команды [[find]] — это не то же самое, что встроенная команда '''''exec'''''. 
<big>'''shopt'''</big> 
Эта команда позволяет изменять ключи (опции) оболочки на лету. Её часто можно встретить в стартовых файлах, но может использоваться и в обычных сценариях. Требует Bash версии 2 или выше.
<source lang="bash">
shopt -s cdspell
# Исправляет незначительные орфографические ошибки в именах каталогов в команде 'cd'
cd /hpme # Oops! Имелось ввиду '/home'.
pwd # /home
# Shell исправил опечатку.
</source> 
<big>'''Команды'''</big> 
<big>'''true'''</big> 
Команда возвращает код завершения — ноль, или успешное завершение, и ничего больше.
<source lang="bash">
# Бесконечный цикл
while true # вместо ":"
do
operation-1
operation-2
...
operation-n
# Следует предусмотреть способ завершения цикла иначе сценарий "зависнет".
done
</source> 
<big>'''false'''</big> 
Возвращает код завершения, свидетельствующий о неудаче, и ничего более.
<source lang="bash">
# Цикл, который никогда не будет исполнен
while false
do
# Следующий код не будет исполнен никогда.
operation-1
operation-2
...
operation-n
done
</source> 
<big>'''type [cmd]'''</big> 
Очень похожа на внешнюю команду '''''which''''', '''''type cmd''''' выводит полный путь к "cmd". В отличие от '''''which''''', '''''type''''' является внутренней командой Bash. С опцией ''-a'' не только различает ключевые слова и внутренние команды, но и определяет местоположение внешних команд с именами, идентичными внутренним.
<source lang="bash">
bash$ type '['
[ is a shell builtin
bash$ type -a '['
[ is a shell builtin
[ is /usr/bin/[
</source> 
<big>'''hash [cmds]'''</big> 
Запоминает путь к заданной команде (в хэш-таблице командной оболочки), благодаря чему, при повторном обращении к ней, оболочка или сценарий уже не будет искать путь к команде в ''$PATH''. При вызове команды '''''hash''''' без аргументов, просто выводит содержимое хэш-таблицы. С ключом ''-r'' — очищает хэш-таблицу. 
<big>'''help'''</big> 
'''''help COMMAND''''' — выводит краткую справку по использованию внутренней команды ''COMMAND''. Аналог команды '''''whatis''''', только для внутренних команд.
<source lang="bash">
bash$ help exit
exit: exit [n]
Exit the shell with a status of N. If N is omitted, the exit status
is that of the last command executed.
</source> 

=== Команды управления заданиями ===
Некоторые из нижеследующих команд принимают, в качестве аргумента, "идентификатор задания" .См. таблицу в конце главы. 
<big>'''jobs'''</big> 
Выводит список заданий, исполняющихся в фоне. Команда [[ps]] более информативна.
''Задания'' и ''процессы'' легко спутать. Некоторые внутренние команды, такие как [[kill]], [[disown]] и [[wait]] принимают в качестве параметра либо номер задания, либо номер процесса. Команды [[fg]], [[bg]] и [[jobs]] принимают только номер задания.
<source lang="bash">
bash$ sleep 100 &
[1] 1384
bash $ jobs
[1]+ Running sleep 100 &
</source>
"1" — это номер задания (управление заданиями осуществляет текущий командный интерпретатор), а "1384" — номер процесса (управление процессами осуществляется системой). Завершить задание/процесс ("прихлопнуть") можно либо командой '''''kill %1''''', либо '''''kill 1384'''''. Спасибо S.C. 
<big>'''disown'''</big> 
Удаляет задание из таблицы активных заданий командной оболочки. 
<big>'''fg,bg'''</big> 
Команда '''''fg''''' переводит задание из фона на передний план. Команда '''''bg''''' перезапускает приостановленное задание в фоновом режиме. Если эти команды были вызваны без указания номера задания, то они воздействуют на текущее исполняющееся задание. 
<big>'''wait'''</big> 
Останавливает работу сценария до тех пор пока не будут завершены все фоновые задания или пока не будет завершено задание/процесс с указанным номером задания/PID процесса. Возвращает код завершения указанного задания/процесса. Вы можете использовать команду '''''wait''''' для предотвращения преждевременного завершения сценария до того, как завершит работу фоновое задание.
 '''Пример''': '''''Ожидание завершения процесса перед тем как продолжить работу.'''''
<source lang="bash">
#!/bin/bash
ROOT_UID=0 # Только пользователь с $UID = 0 имеет привилегии root.
E_NOTROOT=65
E_NOPARAMS=66
if [ "$UID" -ne "$ROOT_UID" ]
then
echo "Для запуска этого сценария вы должны обладать привилегиями root."
exit $E_NOTROOT
fi
if [ -z "$1" ]
then
echo "Порядок использования: `basename $0` имя-файла"
exit $E_NOPARAMS
fi

echo "Обновляется база данных 'locate'..."
echo "Это может занять продолжительное время."
updatedb /usr & # Должна запускаться с правами root.
wait
# В этом месте сценарий приостанавливает свою работу до тех пор, пока не отработает 'updatedb'.
# Желательно обновить базу данных перед тем как выполнить поиск файла.
locate $1
# В худшем случае, без команды wait, сценарий завершил бы свою работу до того,
# как завершила бы работу утилита 'updatedb',
# сделав из неё "осиротевший" процесс.
exit 0
</source>
Команда '''''wait''''' может принимать необязательный параметр — номер задания/процесса,например, ''wait %1'' или ''wait $PPID''. См. таблицу идентификации заданий.
При запуске команды в фоне из сценария может возникнуть ситуация, когда сценарий приостанавливает свою работу до тех пор, пока не будет нажата клавиша ''ENTER''. Это, кажется, происходит с командами, делающими вывод на ''stdout''. Такое поведение может вызывать раздражение у пользователя.
<source lang="bash">
#!/bin/bash
# test.sh

ls -l &
echo "Done."
bash$ ./test.sh
Done.
[bozo@localhost test-scripts]$ total 1
-rwxr-xr-x 1 bozo bozo 34 Oct 11 15:09 test.sh
_
</source>
Разместив команду '''''wait''''', после запуска фонового задания, можно предотвратить такое поведение сценария.
<source lang="bash">
#!/bin/bash
# test.sh

ls -l &
echo "Done."
wait
bash$ ./test.sh
Done.
[bozo@localhost test-scripts]$ total 1
-rwxr-xr-x 1 bozo bozo 34 Oct 11 15:09 test.sh
</source>
Перенаправление вывода в файл или даже на устройство ''/dev/null'' также снимает эту проблему. 
<big>'''suspend'''</big> 
Действует аналогично нажатию на комбинацию клавиш ''Control+Z'', за исключением того, что она приостанавливает работу командной оболочки. 
<big>'''logout'''</big> 
Завершает сеанс работы командной оболочки, можно указать необязательный код завершения. 
<big>'''times'''</big> 
Выдаёт статистику исполнения команд в единицах системного времени, в следующем виде: 
''0m0.020s 0m0.020s''
 
Имеет весьма ограниченную сферу применения, так как сценарии крайне редко подвергаются профилированию. 
<big>'''kill'''</big> 
Принудительное завершение процесса путем передачи ему соответствующего сигнала.
 '''Пример''': '''''Сценарий, завершающий себя сам с помощью команды kill.'''''
<source lang="bash">
#!/bin/bash
# self-destruct.sh
kill $$ # Сценарий завершает себя сам.
# Надеюсь вы ещё не забыли, что "$$" — это PID сценария.
echo "Эта строка никогда не будет выведена."
# Вместо него на stdout будет выведено сообщение "Terminated".
exit 0
# Какой код завершения вернет сценарий?
#sh self-destruct.sh
# echo $?
# 143
#
# 143 = 128 + 15
# сигнал TERM
</source>
Команда ''kill -l'' выведет список всех сигналов. Команда ''kill -9'' — это "жёсткий kill", она используется, как правило, для завершения зависших процессов, которые упорно отказываются "умирать", отвергая простой '''''kill'''''. Иногда достаточно подать команду ''kill -15''. "Процессы-зомби", т.е. процессы, "родители" которых уже завершили работу, не могут быть "убиты" таким способом (невозможно "убить" "мертвого"), рано или поздно с ними"расправится" процесс '''''init'''''. 
<big>'''command'''</big> 
Директива '''''command COMMAND''''' запрещает использование псевдонимов и функций с именем "COMMAND".
Это одна из трёх директив командного интерпретатора, которая влияет на обработку команд. Другие две — ''builtin'' и ''enable''. 
<big>'''builtin'''</big> 
Конструкция ''builtin BUILTIN_COMMAND'' запускает внутреннюю команду "BUILTIN_COMMAND", на время запрещая использование функций и внешних системных команд с тем же именем. 
<big>'''enable'''</big> 
Либо запрещает, либо разрешает вызов внутренних команд. Например, '''''enable -n kill''''' запрещает использование внутренней команды ''kill'', в результате, когда интерпретатор встретит команду ''kill'', то он вызовет внешнюю команду ''kill'', т.е. ''/bin/kill''. 
Команда ''enable -a'' выведет список всех внутренних команд, указывая для каждой — действительно ли она разрешена. Команда ''enable -f filename'' загрузит внутренние команды как разделяемую библиотеку (DLL) из указанного объектного файла.
<big>'''autoload'''</big> 
Перенесена в Bash из ksh. Если функция объявлена как '''''autoload''''', то она будет загружена из внешнего файла в момент первого вызова. Такой приём помогает экономить системные ресурсы. Обратите внимание: '''''autoload''''' не является частью ядра Bash. Её необходимо загрузить с помощью команды ''enable -f'' (см. выше).
 '''Таблица. Идентификация заданий'''
{| class="wikitable" style="margin-left: 300px; margin-right: 0px;"
|-
! Нотация !! Описание
|-
| %N || Номер задания [N]
|-
| %S || Вызов (командная строка) задания, которая начинается со строки S
|-
| %?S || Вызов (командная строка) задания, которая содержит строку S
|-
| %% || "текущее" задание (последнее задание приостановленное на переднем плане или запущенное в фоне)
|-
| %+ || "текущее" задание (последнее задание приостановленное на переднем плане или запущенное в фоне)
|-
| %- || Последнее задание
|-
| $! || Последний фоновый процесс
|-
|}

== Внешние команды, программы и утилиты ==
Благодаря стандартизации набора команд Unix-систем, сценарии, на языке командной оболочки,могут быть легко перенесены из системы в систему практически без изменений. Мощь сценариев складывается из наборов системных команд и директив командной оболочки с простыми программными конструкциями.
=== Базовые команды ===
'''Первая команда, с которой сталкиваются новички''' 
<big>'''ls'''</big> 
Команда вывода "списка" файлов. Многие недооценивают всю мощь этой скромной команды. Например, с ключом -R, рекурсивный обход дерева каталогов, команда [[ls]] выводит содержимое каталогов в виде древовидной структуры. Вот ещё ряд любопытных ключей (опций) команды [[ls]]: ''-S'' — сортировка по размеру файлов, ''-t'' — сортировка по времени последней модификации файла и ''-i'' — выводит список файлов с их ''inode''
 '''Пример''': '''''Создание оглавления диска для записи CD-R, с помощью команды ls.'''''
<source lang="bash">
#!/bin/bash
# burn-cd.sh
# Сценарий, автоматизирующий процесс прожигания CD-R.
SPEED=2 # Если ваше "железо" поддерживает более высокую скорость записи — можете увеличить этот параметр
IMAGEFILE=cdimage.iso
CONTENTSFILE=contents
DEFAULTDIR=/opt # В этом каталоге находятся файлы, которые будут записаны на CD.
# Каталог должен существовать.
# Используется пакет "cdrecord" от Joerg Schilling.
# (http://www.fokus.gmd.de/nthp/employees/schilling/cdrecord.html)

# Если этот сценарий предполагается запускать с правами обычного пользователя,
# то необходимо установить флаг suid на cdrecord
# (chmod u+s /usr/bin/cdrecord, эта команда должна быть выполнена root-ом).
if [ -z "$1" ]
then
IMAGE_DIRECTORY=$DEFAULTDIR
# Каталог по-умолчанию, если иной каталог не задан из командной строки.
else
IMAGE_DIRECTORY=$1
fi
# Создать файл "table of contents".
ls -lRF $IMAGE_DIRECTORY > $IMAGE_DIRECTORY/$CONTENTSFILE
# Ключ "l" — "расширенный" формат вывода списка файлов.
# Ключ "R" — рекурсивный обход дерева каталогов.
# Ключ "F" -- добавляет дополнительные метки к именам файлов (к именам каталогов добавляет оконечный символ /).
echo "Создано оглавление."
# Создать iso-образ.
mkisofs -r -o $IMAGFILE $IMAGE_DIRECTORY
echo "Создан iso-образ файловой системы ISO9660 ($IMAGEFILE)."

# "Прожигание" CD-R.
cdrecord -v -isosize speed=$SPEED dev=0,0 $IMAGEFILE
echo "Запись диска."
echo "Наберитесь терпения, это может потребовать некоторого времени."
exit 0
</source>
<big>'''cat,tac'''</big> 
[[cat]] — это акроним от ''concatenate'', выводит содержимое списка файлов на ''stdout''. Для объединения файлов в один файл может использоваться в комбинации с операциями перенаправления (''>'' или ''>>'').
<source lang="bash">
# Порядок работы с 'cat'
cat filename # Вывод содержимого файла.
cat file.1 file.2 file.3 > file.123 # Объединение содержимого 3-х файлов в одном.
</source>
Ключ ''-n'', команды [[cat]], вставляет порядковые номера строк в выходном файле. Ключ ''-b'' — нумерует только не пустые строки. Ключ ''-v'' выводит непечатаемые символы в нотации с
символом ''^''. Ключ ''-s'' заменяет несколько пустых строк, идущих подряд, одной пустой строкой. 
'''''tac''''' — выводит содержимое файлов в обратном порядке, от последней строки к первой.
<big>'''rev'''</big> 
Выводит все строки файла задом наперёд на ''stdout''. Это не то же самое, что '''''tac'''''. Команда '''''rev''''' сохраняет порядок следования строк, но переворачивает каждую строку задом наперёд.
<source lang="bash">
bash$ cat file1.txt
Это строка 1.
Это строка 2.
bash$ tac file1.txt
Это строка 2.
Это строка 1.
bash$ rev file1.txt.
.1 акортс отЭ
.2 акортс отЭ
</source>
<big>'''cp'''</big> 
Команда копирования файлов. ''cp file1 file2'' скопирует ''file1'' в ''file2'', перезаписав file2, если он уже существовал. 
С флагами ''-a'' и ''-r'', или ''-R'' выполняет копирование дерева каталогов.
<big>'''mv'''</big> 
Команда перемещения файла. Эквивалентна комбинации команд ''cp'' и ''rm''. Может использоваться для перемещения большого количества файлов или для переименования каталогов.
При использовании в неинтерактивных сценариях, команде [[mv]] следует передавать ключ ''-f'', чтобы подавить запрос подтверждения на перемещение. 
Если в качестве каталога назначения указан существующий каталог, то перемещаемый каталог становится подкаталогом каталога назначения.
<source lang="bash">
bash$ mv source_directory target_directory
bash$ ls -lF target_directory
total 1
drwxrwxr-x 2 bozo bozo 1024 May 28 19:20 source_directory/
</source>
<big>'''rm'''</big> 
Удаляет (remove) файл(ы). Ключ ''-f'' позволяет удалять даже файлы ТОЛЬКО-ДЛЯ-ЧТЕНИЯ и подавляет запрос подтверждения на удаление.
При попытке удаления файлов, чьи имена начинаются с символа "-" (дефис), команда [[rm]] будет давать сообщение об ошибке.
<source lang="bash">
bash$ rm -badname
rm: invalid option — b
Try `rm --help' for more information.
</source>
Как вариант можно предложить предварять имена таких файлов точкой-со-слэшем — "./" (путь к файлу в текущем каталоге).
<source lang="bash">
bash$ rm ./-badname
</source>
С ключом ''-r'', удалит все файлы в подкаталогах, начиная с текущего. 
<big>'''rmdir'''</big> 
Удаляет каталог. Удаляемый каталог не должен содержать файлов, включая "скрытые файлы", иначе каталог не будет удалён. 
<big>'''mkdir'''</big> 
Создаёт новый каталог, например: 
'''''mkdir -p project/programs/December''''' 
создаёт каталог с заданным именем в требуемом каталоге. Ключ ''-p'' позволяет создавать промежуточные родительские каталоги. 
<big>'''chmod'''</big> 
Изменяет атрибуты существующего файла.
<source lang="bash">
chmod +x filename
# Делает файл "filename" доступным для исполнения всем пользователям.

chmod u+s filename
# Устанавливается бит "suid" для "filename".
# В результате, любой пользователь сможет запустить "filename" с привилегиями владельца файла.
# (Это не относится к файлам-сценариям на языке командной оболочки.)

chmod 644 filename
# Выдаёт право на запись/чтение владельцу файла "filename", и право на чтение всем остальным (восьмеричное число).

chmod 1777 directory-name
# Выдаёт право на чтение, запись и исполнение файлов в каталоге,
# дополнительно устанавливает "sticky bit".
# Это означает, что удалять файлы в этом каталоге могут только владельцы файлов,
# владелец каталога и, само собой разумеется, root.
</source>
<big>'''chattr'''</big> 
Изменяет атрибуты файла. Эта команда подобна команде '''''chmod''''', за исключением синтаксиса вызова, и работает исключительно в файловой системе ext2. 
<big>'''ln'''</big> 
Создаёт ссылку на существующий файл. Позволяет задавать несколько имён одному и тому же файлу и представляет из себя превосходную альтернативу "псевдонимам" (алиасам).
Размер файла-ссылки, создаваемого командой [[ln]], имеет длину всего в несколько байт. 
Чаще всего команда [[ln]] используется с ключом ''-s'', который служит для создания ''символической''(''symbolic''), или ''"мягкой"'' (''"soft"'') ссылки. Без этого флага, команда создает полноценную копию имени файла. С ключом ''--'' только ссылку, указывающую на заданный файл. Дополнительное преимущество ключа ''-s'' состоит в том, что он позволяет создавать ссылки на файлы, расположенные в других файловых системах. 
Синтаксис команды достаточно прост. Например, команда: 
'''''ln -s oldfile newfile'''''
создаст ссылку, с именем ''newfile'', на существующий файл ''oldfile'', если файл с именем ''newfile'' уже существует, то он будет удален командой [[ln]].
{| class="wikitable"
|-
! Какого типа ссылки лучше использовать?
|-
| John Macdonald дает свой ответ на этот вопрос:
Без сомнения, оба варианта ссылок предоставляют возможность обращаться к файлу (к его содержимому). Так, если вы редактируете содержимое файла, загрузив его в редактор по имени ссылки, то внесённые изменения вы увидите, если откроете файл с использованием его оригинального имени. Различия между "жёсткими" и "мягкими" ссылками начинают проявляться когда вы поднимаетесь на более высокий уровень. Удаление или переименование файла, на который имеется "жёсткая" ссылка, никак не воздействует на ссылку. Она по прежнему продолжает ссылаться на файл (файл физически удаляется с диска только тогда, когда будет удалена последняя "жёсткая" ссылка на него, прим. перев.). В случае же с "мягкой" ссылкой всё наоборот — файл удаляется (переименовывается), а ссылка продолжает ссылаться на прежнее имя файла (так получаются "битые" ссылки, прим. перев.). Но главное преимущество "мягких" ссылок перед "жёсткими" состоит в том, что они могут указывать на файлы в других файловых системах (фактически, "мягкие" ссылки ссылаются не на дисковые блоки, где расположен файл, а на имя этого файла).
|}
Ссылки дают возможность запускать одну и ту же программу или сценарий, использую различные имена. В этом случае программист может предусмотреть свой вариант развития событий для каждого из имён.
 '''Пример''': '''''Здравствуй или Прощай.'''''
<source lang="bash">
#!/bin/bash
# hello.sh: Говорит "hello" или "goodbye"
# в зависимости от того под каким именем был вызван сценарий.
# Создайте ссылку на этот сценарий:
# ln -s hello.sh goodbye
# И попробуйте вызвать его под разными именами:
# ./hello.sh
# ./goodbye
HELLO_CALL=65
GOODBYE_CALL=66
if [ $0 = "./goodbye" ]
then
echo "Пока!"
# Можете вставить свой вариант прощания.
exit $GOODBYECALL
fi
echo "Привет!"
# Можете вставить свой вариант приветствия.
exit $HELLO_CALL
</source>
<big>'''man,info'''</big> 
Команды доступа к справочным и информационным страницам по системным командам и установленным программам и утилитам. Как правило, страницы '''''info''''' содержат более подробную информацию, чем '''''man'''''.

=== Более сложные команды ===
'''Команды для более опытных пользователей''' 
<big>'''find'''</big> 
'''''-exec''''' ''COMMAND \''; 
Для каждого найденного файла, соответствующего заданному шаблону поиска, выполняет команду ''COMMAND''. Командная строка должна завершаться последовательностью символов ''\;'' (здесь символ ";" экранирован обратным слэшем, чтобы информировать командную оболочку о том, что символ ";" должен быть передан команде [[find]] как обычный символ). Если ''COMMAND'' содержит ''{}'', то [[find]] подставляет полное имя найденного файла вместо "{}".
<source lang="bash">
bash$ find ~/ -name '*.txt'
/home/bozo/.kde/share/apps/karm/karmdata.txt
/home/bozo/misc/irmeyc.txt
/home/bozo/test-scripts/1.txt
</source> 
<source lang="bash">
find /home/bozo/projects -mtime 1# Найти все файлы в каталоге /home/bozo/projects и вложенных подкаталогах,
# Найти все файлы в каталоге /home/bozo/projects и вложенных подкаталогах,
# которые изменялись в течение последних суток.
# mtime = время последнего изменения файла
# ctime = время последнего изменения атрибутов файла (через 'chmod' или как-то иначе)
# atime = время последнего обращения к файлу
DIR=/home/bozo/junk_files
find "$DIR" -type f -atime +5 -exec rm {} \;
# Удалить все файлы в каталоге "/home/bozo/junk_files"
# к которым не было обращений в течение последних 5 дней.
# "-type filetype", где
# f = обычный файл
# d = каталог, и т.п.
# (Полный список ключей вы найдете в 'man find'.)
find /etc -exec grep '[0-9][0-9]*[.][0-9][0-9]*[.][0-9][0-9]*[.][0-9][0-9]*' {} \;
# Поиск всех IP-адресов (xxx.xxx.xxx.xxx) в файлах каталога /etc.
# Однако эта команда выводит не только IP-адреса, как этого избежать?
# Примерно так:
find /etc -type f -exec cat '{}' \; | tr -c '.[:digit:]' '\n' \
| grep '^[^.][^.]*\.[^.][^.]*\.[^.][^.]*\.[^.][^.]*$'
# [:digit:] — один из символьных классов
# введен в стандарт POSIX 1003.2.
# Спасибо S.C.
</source>
Не следует путать опцию ''-exec'' команды [[find]] с внутренней командой Bash — exec.
 '''Пример''': '''''Badname, удаление файлов в текущем каталоге, имена которых содержат недопустимые символы и пробелы.'''''
<source lang="bash">
#!/bin/bash
# Удаление файлов в текущем каталоге, чьи имена содержат недопустимые символы.
for filename in *
do
badname=`echo "$filename" | sed -n /[\+\{\;\"\\\=\?~\<\>\&\*\|\$]/p`
# Недопустимые символы в именах файлов: + { ; " \ = ? ~ ( ) < > & * | $
rm $badname 2>/dev/null # Сообщения об ошибках "выстреливаются" в никуда.
done
# Теперь "позаботимся" о файлах, чьи имена содержат пробельные символы.
find . -name "* *" -exec rm -f {} \;
# На место "{}", find подставит полное имя файла.
# Символ '\' указывает на то, что ';' интерпретируется как обычный символ, а не как конец команды.
exit 0
#---------------------------------------------------------------------
# Строки, приведённые ниже, не будут выполнены, т.к. выше стоит команда "exit".
# Альтернативный вариант сценария:
find . -name '*[+{;"\\=?~()<>&*|$ ]*' -exec rm -f '{}' \;
exit 0
# (Спасибо S.C.)
</source>
 '''Пример''': '''''Удаление файла по его номеру inode.'''''
<source lang="bash">
#!/bin/bash
# idelete.sh: Удаление файла по номеру inode.
# Этот прием используется в тех случаях, когда имя файла начинается с недопустимого символа,
# например, ? или -.
ARGCOUNT=1 # Имя файла должно быть передано в сценарий.
E_WRONGARGS=70
E_FILE_NOT_EXIST=71
E_CHANGED_MIND=72
if [ $# -ne "$ARGCOUNT" ]
then
echo "Порядок использования: `basename $0` filename"
exit $E_WRONGARGS
fi
if [ ! -e "$1" ]
then
echo "Файл \""$1"\" не найден."
exit $E_FILE_NOT_EXIST
fi
inum=`ls -i | grep "$1" | awk '{print $1}'`
# inum = номер inode (index node) файла
# Каждый файл имеет свой inode, где хранится информация о физическом расположении файла.
echo; echo -n "Вы совершенно уверены в том, что желаете удалить \"$1\" (y/n)? "
# Ключ '-v' в команде 'rm' тоже заставит команду вывести подобный запрос.
read answer
case "$answer" in
[nN]) echo "Передумали?"
exit $E_CHANGED_MIND
;;
*) echo "Удаление файла \"$1\".";;
esac
find . -inum $inum -exec rm {} \;
echo "Файл "\"$1"\" удалён!"
exit 0
</source>
Дополнительные примеры по использованию команды [[find]] вы найдете в страницах справочного руководства (''man find'') вы найдете более подробную информацию об этой достаточно сложной и мощной команде.
<big>'''xargs'''</big> 
Команда передачи аргументов указанной команде. Она разбивает поток аргументов на отдельные составляющие и поочередно передаёт их заданной команде для обработки. Эта команда может рассматриваться как мощная замена обратным одинарным кавычкам. Зачастую, когда команды, заключенные в обратные одиночные кавычки, завершаются с ошибкой ''too many arguments'' (слишком много аргументов), использование '''''xargs''''' позволяет обойти это ограничение. Обычно, ''xargs'' считывает список аргументов со стандартного устройства ввода ''stdin'' или из канала (конвейера), но может считывать информацию и из файла. 
Если команда не задана, то по-умолчанию выполняется [[echo]]. При передаче аргументов по конвейеру, '''''xargs''''' допускает наличие пробельных символов и символов перевода строки, которые затем автоматически отбрасываются.
<source lang="bash">
bash$ ls -l
total 0
-rw-rw-r-- 1 bozo bozo 0 Jan 29 23:58 file1
-rw-rw-r-- 1 bozo bozo 0 Jan 29 23:58 file2
bash$ ls -l | xargs
total 0 -rw-rw-r-- 1 bozo bozo 0 Jan 29 23:58 file1 -rw-rw-r-- 1 bozo bozo 0 Jan 29 23:58
file2
</source> 
<source lang="bash">ls | xargs -p -l gzip</source> — упакует с помощью [[gzip]] все файлы в текущем каталоге, выводя запрос на подтверждение для каждого файла. 
'''''xargs''''' имеет очень любопытный ключ ''-n NN'', который ограничивает количество передаваемых аргументов за один "присест" числом ''NN''. 
<source lang="bash">ls | xargs -n 8 echo</source> — выведет список файлов текущего каталога в 8 колонок. 
Ещё одна полезная опция — -0, в комбинации с '''''find -print 0''''' или '''''grep -lZ''''' позволяет обрабатывать аргументы, содержащие пробелы и кавычки. 
<source lang="bash">find / -type f -print0 | xargs -0 grep -liwZ GUI | xargs -0 rm -f</source> 
<source lang="bash">grep -rliwZ GUI / | xargs -0 rm -f</source>
Обе вышеприведенные команды удалят все файлы, содержащие в своём имени комбинацию символов "GUI". (Спасибо S.C.)
 '''Пример''': '''''Использование команды xargs для мониторинга системного журнала.'''''
<source lang="bash">
#!/bin/bash
# Создание временного файла мониторинга в текущем каталоге,
# куда переписываются несколько последних строк из /var/log/messages.
# Обратите внимание: если сценарий запускается обычным пользователем,
# то файл /var/log/messages должен быть доступен на чтение этому пользователю.
# #root chmod 644 /var/log/messages
LINES=5( date; uname -a ) >>logfile
# Время и информация о системе
echo --------------------------------------------------------------------- >>logfile
tail -$LINES /var/log/messages | xargs | fmt -s >>logfile
echo >>logfile
echo >>logfileexit 0
# Упражнение:
# --------
# Измените сценарий таким образом, чтобы он мог отслеживать изменения в /var/log/messages
# с интервалом в 20 минут.
# Подсказка: воспользуйтесь командой "watch".
</source>

 '''Пример''': '''''copydir, копирование файлов из текущего каталога в другое место.'''''
<source lang="bash">
#!/bin/bash
# Копирует все файлы из текущего каталога
# в каталог, указанный в командной строке.
if [ -z "$1" ] # Выход, если каталог назначения не задан.
then
echo "Порядок использования: `basename $0` directory-to-copy-to"
exit 65
fi
ls . | xargs -i -t cp ./{} $1 # Этот сценария является точным эквивалентом
# cp * $1
# если в именах файлов не содержатся пробельные символы.
exit 0
</source>

 '''Пример''': '''''Завершение работы процесса по его имени.'''''
<source lang="bash">
#!/bin/bash
# kill-byname.sh: Завершение работы процесса по его имени.
# Сравните этот сценарий с kill-process.sh.
# Пример,
# Попробуйте запустить команду "./kill-byname.sh xterm" —
#+ и понаблюдайте как закроются все окна xterm.
# Внимание:
# --------
# Этот сценарий может представлять определенную угрозу.
# Запуск этого сценария (особенно с правами root)
# может привести к потере несохранённых данных и другим неожиданным эффектам.
E_BADARGS=66
if test -z "$1" # Проверка — задано ли имя процесса
then
echo "Порядок использования: `basename $0` останавливаемый(ые)_процесс(ы)"
exit $E_BADARGS
fi
# ---------------------------------------------------------
# Примечание:
# Ключ -i команды xargs — это "замена строки" .
# Фигурные скобки — это замещаемая строка.
# 2&>/dev/null — подавляет вывод сообщений об ошибках.
# ---------------------------------------------------------
PROCESS_NAME="$1"
ps ax | grep "$PROCESS_NAME" | awk '{print $1}' | xargs -i kill {} 2&>/dev/null
exit $?
</source>

 '''Пример''': '''''Подсчёт частоты встречаемости слов using xargs.'''''
<source lang="bash">
#!/bin/bash
# wf2.sh: Грубый подсчёт частоты встречаемости слова в текстовом файле.
# Команда 'xargs' используется для выделения отдельных слов из строки.
# Сравните этот сценарий с "wf.sh".
# Проверка — задано ли имя файла из командной строки.
ARGS=1
E_BADARGS=65
E_NOFILE=66
if [ $# -ne "$ARGS" ]
# Передано корректное число аргументов?
then
echo "Порядок использования: `basename $0` имя_файла"
exit $E_BADARGS
fi
if [ ! -f "$1" ] # Проверка наличия файла.
then
echo "Файл \"$1\" не найден."
exit $E_NOFILE
fi
#######################################################
cat "$1" | xargs -n1 | \
# Вывод содержимого файла, по одному слову в строке.
tr A-Z a-z | \
# Преобразование в нижний регистр.
sed -e 's/\.//g' -e 's/\,//g' -e 's/ /\
/g' | \
# Отбросить точки и запятые и
# заменить пробелы символами перевода строки,
sort | uniq -c | sort -nr # В заключение — подсчитать и отсортировать по частоте встречаемости.
#######################################################
# Этот сценарий выполняет те же действия, что и "wf.sh",
# но он более "тяжелый" и работает значительно медленнее.
exit 0
</source>
<big>'''expr'''</big> 
Универсальный обработчик выражений: вычисляет заданное выражение (аргументы должны отделяться пробелами). Выражения могут быть арифметическими, логическими или строковыми. 
<source lang="bash">expr 3 + 5</source>
возвратит 8
<source lang="bash">expr 5 % 3</source>
возвратит 2
<source lang="bash">expr 5 \* 3</source>
возвратит 15
В арифметических выражениях, оператор умножения обязательно должен экранироваться обратным слэшем.
<source lang="bash">y=`expr $y + 1`</source>
Операция инкремента переменной, то же самое, что и let y=y+1, или y=$(($y+1)). Пример подстановки арифметических выражений.
<source lang="bash">z=`expr substr $string $position $length`</source>
Извлекает подстроку длиной $length символов, начиная с позиции $position.
 '''Пример''': '''''Пример работы с expr.'''''
<source lang="bash">
#!/bin/bash
# Демонстрация некоторых приемов работы с командой 'expr'
# =======================================
echo
# Арифметические операции
# ----------------------
echo "Арифметические операции"
echo
a=`expr 5 + 3`
echo "5 + 3 = $a"
a=`expr $a + 1`
echo
echo "a + 1 = $a"
echo "(инкремент переменной)"

a=`expr 5 % 3`
# остаток от деления (деление по модулю)
echo
echo "5 mod 3 = $a"
echo
echo# Логические операции
# ------------------

# Возвращает 1 если выражение истинно, 0 — если ложно,
# в противоположность соглашениям, принятым в Bash.

echo "Логические операции"
echo
x=24
y=25
b=`expr $x = $y` # Сравнение.
echo "b = $b" # 0 ( $x -ne $y )
echo
a=3b=`expr $a \> 10`
echo 'b=`expr $a \> 10`, поэтому...'
echo "Если a > 10, то b = 0 (ложь)"
echo "b = $b" # 0 ( 3 ! -gt 10 )
echo
b=`expr $a \< 10`
echo "Если a < 10, то b = 1 (истина)"
echo "b = $b" # 1 ( 3 -lt 10 )
echo
# Обратите внимание на необходимость экранирования операторов.
b=`expr $a \<= 3`
echo "Если a <= 3, то b = 1 (истина)"
echo "b = $b" # 1 ( 3 -le 3 )
# Существует еще оператор "\>=" (больше или равно).
echo
echo
# Операции сравнения
#-----------------
echo "Операции сравнения"
echo
a=zipper
echo "a is $a"
if [ `expr $a = snap` ]
then
echo "a -- это не zipper"
fi
echo
echo

# Операции со строками
#------------------
echo "Операции со строками"
echo
a=1234
zipper43231
echo "Строка над которой производятся операции: \"$a\"."
# length: длина строки
b=`expr length $a`
echo "длина строки \"$a\" равна $b."
# index: позиция первого символа подстроки в строке
b=`expr index $a 23`
echo "Позиция первого символа \"2\" в строке \"$a\" : \"$b\"."
# substr: извлечение подстроки, начиная с заданной позиции, указанной длины
b=`expr substr $a 2 6`
echo "Подстрока в строке \"$a\", начиная с позиции 2,\
и длиной в 6 символов: \"$b\"."
# При выполнении поиска по шаблону, по-умолчанию поиск
# начинается с ***начала*** строки.
#
# Использование регулярных выражений
b=`expr match "$a" '[0-9]*'` # Подсчёт количества цифр.
echo Количество цифр с начала строки \"$a\" : $b.
b=`expr match "$a" '$[0-9]*$'` # Обратите внимание на экранирование круглых скобок
# == ==
echo "Цифры, стоящие в начале строки \"$a\" : \"$b\"."
echo
exit 0
</source>
Вместо оператора '''''match''''' можно использовать оператор '':'' . Например, команда
<source lang="bash">b=`expr $a : [0-9]*`</source>
является точным эквивалентом для 
<source lang="bash">b=`expr match $a [0-9]*`</source> в примере, рассмотренном выше. 
<source lang="bash">
#!/bin/bash
echo
echo "Операции над строками с использованием конструкции \"expr \$string : \""
echo
"========================================================================"
echo
a=1234zipper5FLIPPER43231

echo "Строка, над которой выполняются операции: \"`expr "$a" : '$.*$'`\"."
# Экранирование круглых скобок в шаблоне == ==

# Если скобки не экранировать...
# то 'expr' преобразует строковый операнд в целое число.
echo "Длина строки \"$a\" равна `expr "$a" : '.*'`."
# Длина строки
echo "Количество цифр с начала строки \"$a\" равно `expr "$a" : '[0-9]*'`."
# -------------------------------------------------------------------------
#
echo
echo "Цифры, стоящие в начале строки \"$a\" : `expr "$a" : '$[0-9]*$'`."
# == ==
echo "Первые 7 символов в строке \"$a\" : `expr "$a" : '$.......$'`."
# ====== == ==
# Опять же, необходимо экранировать круглые скобки в шаблоне.
#
echo "Последние 7 символов в строке \"$a\" : `expr "$a" : '.*$.......$'`."
# ========= оператор конца строки ^^
# (фактически означает переход через любое количество символов, пока
# не будет найдена требуемая подстрока)
echo
exit 0
</source>
Этот пример демонстрирует необходимость экранирования оператора группировки — ''$ ... $'' в регулярных выражениях, при поиске по шаблону командой '''''expr'''''.
Perl, [[sed]] и [[awk]] имеют в своем распоряжении более мощный аппарат анализа строк. Коротенький скрипт на [[sed]] или [[awk]], внутри сценария — значительно более привлекательная альтернатива использованию '''''expr''''' при анализе строк.

=== Команды для работы с датой и временем ===
'''Время/дата и измерение интервалов времени''' 
<big>'''date'''</big> 
Команда [[date]] без параметров выводит дату и время на стандартное устройство вывода ''stdout''. Она становится гораздо интереснее при использовании дополнительных ключей форматирования вывода.
 '''Пример''': '''''Команда date.'''''
<source lang="bash">
#!/bin/bash
# Примеры использования команды 'date'echo "Количество дней, прошедших с начала года: `date +%j`."
# Символ '+' обязателен при использовании форматирующего аргумента
# %j, возвращающего количество дней, прошедших с начала года.
echo "Количество секунд, прошедших с 01/01/1970 : `date +%s`."
# %s количество секунд, прошедших с начала "эпохи UNIX",
# но насколько этот ключ полезен?

prefix=tempsuffix=`eval date +%s`
# Ключ "+%s" характерен для GNU-версии 'date'.
filename=$prefix.$suffix
echo $filename
# Прекрасный способ получения "уникального" имени для временного файла,
# даже лучше, чем с использованием $$.
# Дополнительную информацию вы найдете в 'man date'.
exit 0
</source>
Ключ ''-u'' даёт UTC время (Universal Coordinated Time — время по Гринвичу).
<source lang="bash">
bash$ date
Fri Mar 29 21:07:39 MST 2002
bash$ date -u
Sat Mar 30 04:07:42 UTC 2002
</source>
Команда '''''date''''' имеет ряд дополнительных ключей форматирования вывода. Например, ''%N'' выводит долю наносекунд текущего времени. Этому ключу формата можно привести одно весьма любопытное применение — ''генерация шестизначных псевдослучайных целых чисел''.
<source lang="bash">
date +%N | sed -e 's/000$//' -e 's/^0//'
# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
# Удаление ведущих и завершающих нулей, если таковые присутствуют.
</source>
<big>'''zdump'''</big> 
Отображает время для указанной временной зоны.
<source lang="bash">
bash$ zdump EST
EST Tue Sep 18 22:09:22 2001 EST
</source>
<big>'''time'''</big> 
Выводит подробную статистику по исполнению некоторой команды.
<source lang="bash">time ls -l / </source>
даст нечто подобное: 
'' 0.00 user 0.01 system 0:00.05 elapsed 16% CPU (0 avgtext + 0a vgdata 0 maxresident) k 0 inputs + 0 outputs (149 major + 27 minor) page faults 0 swaps'' 
Начиная с версии 2.0 Bash, команда '''''time''''' стала зарезервированным словом интерпретатора, с несколько изменённым поведением в конвейере. 
<big>'''touch'''</big> 
Утилита устанавливает время последнего обращения/изменения файла в текущее системное время или в заданное время, но так же может использоваться для создания нового пустого файла. Команда '''''touch zzz''''' создаст новый пустой файл с именем ''zzz'', если перед этим файл ''zzz'' отсутствовал. Кроме того, такие пустые файлы могут использоваться для индикации, например, времени последнего изменения в проекте. 
Эквивалентом команды [[touch — Команда создания пустого файла и модификации времени последнего изменения файла | touch]] могут служить ''''': >> newfile''''' или '''''>> newfile''''' (для обычных файлов). 
<big>'''at'''</big> 
Команда '''''at''''' — используется для запуска заданий в заданное время. В общих чертах она напоминает ''cron'', однако, '''''at''''' используется для однократного запуска набора команд.
''at 2pm January 15'' — попросит ввести набор команд, которые необходимо запустить в указанное время. Эти команды должны быть совместимыми со сценариями командной оболочки. Ввод завершается нажатием комбинации клавиш ''Ctl-D''. 
Ключ ''-f'' или операция перенаправления ввода (''<''), заставляет '''''at''''' прочитать список команд из файла. Этот файл должен представлять из себя обычный сценарий, на языке командной оболочки и, само собой разумеется, такой сценарий должен быть неинтерактивным. Может использоваться совместно с командой ''run-parts'' для запуска различных наборов сценариев.
<source lang="bash">bash$ at 2:30 am Friday < at-jobs.listjob 2 at 2000-10-27 02:30</source>
<big>'''batch'''</big> 
Команда '''''batch''''', управляющая запуском заданий, напоминает команду '''''at''''', но запускает список команд только тогда, когда загруженность системы упадет ниже ''.8''. Подобно команде '''''at''''', с ключом ''-f'', может считывать набор команд из файла. 
<big>'''cal'''</big> 
Выводит на ''stdout'' аккуратно отформатированный календарь на текущий месяц. Может выводить календарь за определенный год. 
<big>'''sleep'''</big> 
Приостанавливает исполнение сценария на заданное количество секунд, ничего не делая. Может использоваться для синхронизации процессов, запущенных в фоне, проверяя наступление ожидаемого события так часто, как это необходимо.
<source lang="bash">sleep 3 # Пауза, длительностью в 3 секунды.</source>
Команда '''''sleep''''' по-умолчанию принимает количество секунд, но ей можно передать и количество часов и минут и даже дней.
<source lang="bash">sleep 3 h # Приостановка на 3 часа!</source>
Для запуска команд через заданные интервалы времени лучше использовать '''''watch'''''. 
<big>'''usleep'''</big> 
Microsleep (здесь символ "u" должен читаться как буква греческого алфавита — "мю", или префикс микро). Это то же самое, что и sleep, только интервал времени задается в микросекундах. Может использоваться для очень тонкой синхронизации процессов. 
<source lang="bash">usleep 30 # Приостановка на 30 микросекунд.</source> 
Эта команда является частью пакета initscripts/rc-scripts в дистрибутиве Red Hat. Команда '''''usleep''''' не обеспечивает особую точность соблюдения интервалов, и поэтому она не подходит для применений, критичных ко времени. 
<big>'''hwclock,clock'''</big> 
Команда '''''hwclock''''' используется для получения доступа или коррекции аппаратных часов компьютера. С некоторыми ключами требует наличия привилегий root. Сценарий /etc/rc.d/rc.sysinit использует команду '''''hwclock''''' для установки системного времени во время загрузки.
Команда '''''clock''''' — это синоним команды '''''hwclock'''''.

=== Команды обработки текста ===
<big>'''sort'''</big> 
Сортирует содержимое файла, часто используется как промежуточный фильтр в конвейерах. Эта команда сортирует поток текста в порядке убывания или возрастания, в зависимости от заданных опций. Ключ ''-m'' используется для сортировки и объединения входных файлов. В странице '''''info''''' перечислено большое количество возможных вариантов ключей. 
<big>'''tsort'''</big> 
Топологическая сортировка, считывает пары строк, разделённых пробельными символами, и выполняет сортировку, в зависимости от заданного шаблона. 
<big>'''uniq'''</big> 
Удаляет повторяющиеся строки из отсортированного файла. Эту команду часто можно встретить в конвейере с командой '''''sort'''''. 
<source lang="bash">
cat list-1 list-2 list-3 | sort | uniq > final.list
# Содержимое файлов, сортируется,
# затем удаляются повторяющиеся строки,
# и результат записывается в выходной файл final.list.
</source>
Ключ ''-c'' выводит количество повторяющихся строк.
<source lang="bash">
bash$ cat testfile
Эта строка встречается только один раз.
Эта строка встречается дважды.
Эта строка встречается дважды.
Эта строка встречается трижды.
Эта строка встречается трижды.
Эта строка встречается трижды.

bash$ uniq -c testfile
1 Эта строка встречается только один раз.
2 Эта строка встречается дважды.
3 Эта строка встречается трижды.

bash$ sort testfile | uniq -c | sort -nr
3 Эта строка встречается трижды.
2 Эта строка встречается дважды.
1 Эта строка встречается только один раз.
</source>

Команда '''''sort INPUTFILE | uniq -c | sort -nr''''' выводит статистику встречаемости строк в файле INPUTFILE (ключ ''-nr'', в команде '''''sort''''', означает сортировку в порядке убывания). Этот шаблон может с успехом использоваться при анализе файлов системного журнала, словарей и везде, где необходимо проанализировать лексическую структуру документа.
 '''Пример''': '''''Частота встречаемости отдельных слов.'''''
<source lang="bash">
#!/bin/bash
# wf.sh: "Сырой" анализ частоты встречаемости слова в текстовом файле.
ARGS=1
E_BADARGS=65
E_NOFILE=66
if [ $# -ne "$ARGS" ] # Файл для анализа задан?
then
echo "Порядок использования: `basename $0` filename"
exit $E_BADARGS
fi
if [ ! -f "$1" ] # Проверка существования файла.
then
echo "Файл \"$1\" не найден."
exit $E_NOFILE
fi
########################################################
# main ()
sed -e 's/\.//g' -e 's/ /\
/g' "$1" | tr 'A-Z' 'a-z' | sort | uniq -c | sort -nr
# =========================
# Подсчёт количества вхождений
# Точки и пробелы заменяются
# символами перевода строки,
# затем символы переводятся в нижний регистр
# и наконец подсчитывается количество вхождений,
# и выполняется сортировка по числу вхождений.
########################################################
# Упражнения:
# ---------
# 1) Добавьте команду 'sed' для отсечения других знаков пунктуации, например, запятых.
# 2) Добавьте удаление лишних пробелов и других пробельных символов.
# 3) Добавьте дополнительную сортировку так, чтобы слова с одинаковой частотой встречаемости
# сортировались бы в алфавитном порядке.
exit 0
</source> 
<source lang="bash">
bash$ cat testfile
Эта строка встречается только один раз.
Эта строка встречается дважды.
Эта строка встречается дважды.
Эта строка встречается трижды.
Эта строка встречается трижды.
Эта строка встречается трижды.

bash$ ./wf.sh testfile
6 Эта
6 встречается
6 строка
3 трижды
2 дважды
1 только
1 один
1 раз
</source>
<big>'''expand,unexpand'''</big> 
Команда '''''expand''''' преобразует символы табуляции в пробелы. Часто используется в конвейерной обработке текста. 
Команда '''''unexpand''''' преобразует пробелы в символы табуляции. Т.е. она является обратной по отношению к команде '''''expand'''''.
<big>'''cut'''</big> 
Предназначена для извлечения отдельных полей из текстовых файлов. Напоминает команду ''print $N'' в [[awk]], но более ограничена в своих возможностях. В простейших случаях может быть неплохой заменой [[awk]] в сценариях. Особую значимость, для команды '''''cut''''', представляют ключи ''-d'' (разделитель полей) и ''-f'' (номер(а) поля(ей)). 
Использование команды '''''cut''''' для получения списка смонтированных файловых систем: 
<source lang="bash">
cat /etc/mtab | cut -d ' ' -f1,2
</source> 
Использование команды '''''cut''''' для получения версии ОС и ядра: 
<source lang="bash">uname -a | cut -d" " -f1,3,11,12</source> 
Использование команды '''''cut''''' для извлечения заголовков сообщений из электронных писем: 
<source lang="bash">
bash$ grep '^Subject:' read-messages | cut -c10-80
Re: Linux suitable for mission-critical apps?
MAKE MILLIONS WORKING AT HOME3
Spam complaint
Re: Spam complaint
</source> 
Использование команды cut при разборе текстового файла: 
<source lang="bash">
# Список пользователей в /etc/passwd.
FILENAME=/etc/passwd
for user in $(cut -d: -f1 $FILENAME)
do
echo $user
done# Спасибо Oleg Philon за этот пример.
</source> 
'''''cut -d ' ' -f2,3 filename''''' эквивалентно '''''awk -F'[ ]' '{ print $2, $3 }' filename''''' 
<big>'''paste'''</big> 
Используется для объединения нескольких файлов в один многоколоночный файл. 
<big>'''join'''</big> 
Может рассматриваться как команда, родственная команде '''''paste'''''. Эта мощная утилита позволяет объединять два файла по общему полю, что представляет собой упрощённую версию реляционной базы данных. 
Команда '''''join''''' оперирует только двумя файлами и объединяет только те строки, которые имеют общее поле (обычно числовое), результат объединения выводится на ''stdout''. Объединяемые файлы должны быть отсортированы по ключевому полю.
<source lang="bash">
File: 1.data
100 Shoes
200 Laces
300 Socks

File: 2.data
100 $40.00
200 $1.00
300 $2.00

bash$ join 1.data 2.data
File: 1.data 2.data
100 Shoes $40.00
200 Laces $1.00
300 Socks $2.00
</source> 
На выходе ключевое поле встречается только один раз. 
<big>'''head'''</big> 
Выводит начальные строки из файла на ''stdout'' (по-умолчанию — 10 строк, но это число можно задать иным). Эта команда имеет ряд интересных ключей. 
 '''Пример''': '''''Какие из файлов являются сценариями?'''''
<source lang="bash">
#!/bin/bash
# script-detector.sh: Отыскивает файлы сценариев в каталоге.
TESTCHARS=2 # Проверяются первые два символа.
SHABANG='#!' # Сценарии как правило начинаются с "sha-bang."
for file in * # Обход всех файлов в каталоге.
do
if [[ `head -c$TESTCHARS "$file"` = "$SHABANG" ]]
# head -c2 #!
# Ключ '-c' в команде "head" выводит заданное
# количество символов, а не строк.
then
echo "Файл \"$file\" -- сценарий."
else
echo "Файл \"$file\" не является сценарием."
fi
done
exit 0
</source> 
 '''Пример''': '''''Генератор 10-значных случайных чисел.'''''
<source lang="bash">
#!/bin/bash
# rnd.sh: Генератор 10-значных случайных чисел
# Автор: Stephane Chazelas.
head -c4 /dev/urandom | od -N4 -tu4 | sed -ne '1s/.* //p'
# =================================================================== #
# Описание
# --------
# head:
# -c4 — первые 4 байта.
# od:
# -N4 ограничивает вывод 4-мя байтами.
# -tu4 беззнаковый десятичный формат вывода.
# sed:
# -n, в комбинации с флагом "p", в команде "s",
# выводит только совпадающие с шаблоном строки.

# Автор сценария описывает действия 'sed' таким образом:
# head -c4 /dev/urandom | od -N4 -tu4 | sed -ne '1s/.* //p'
# ----------------------------------> |
# Передаёт вывод в "sed" --------> |
# пусть это будет 0000000 1198195154\n
# sed начинает читать символы: 0000000 1198195154\n.
# Здесь он находит символ перевода строки,
# таким образом он получает строку (0000000 1198195154).
# Затем он просматривает <диапазон><действие>. Первый и единственный — это
# диапазон действие# 1 s/.* //p
# Номер строки попадает в заданный диапазон, так что теперь он приступает к выполнению действия:
# пытается заменить наибольшую подстроку, заканчивающуюся пробелом
# ("0000000 ") "ничем" (//), и если замена произведена — выводит результат
# ("p" -- это флаг команды "s", а не команда "p", которая имеет иное значение).
# теперь sed готов продолжить чтение входного потока. (Обратите внимание:
# если опустить ключ -n, то sed выведет строку ещё раз)
# Теперь sed дочитывает остаток строки.
# Он готов приступить к анализу 2-й строки (которая отмечена '$'
# как последняя).
# Поскольку строка не попадает в заданный <диапазон>, на этом обработка прекращается.
# Проще говоря, команда sed означает:
# "В первой строке удалить любые символы, вплоть до последнего встреченного пробела, и затем вывести остаток."
# Сделать это можно более простым способом:
# sed -e 's/.* //;q'
# Где, заданы два <диапазона><действия> (можно записать и по другому
# sed -e 's/.* //' -e q):
# диапазон действие
# ничего (для совпадающих строк) s/.* //
# ничего (для совпадающих строк) q (quit)
# Здесь sed считывает только первую строку.
# Выполняет оба действия, и выводит строку перед завершением
# (действие "q"), поскольку ключ "-n" опущен.
# =================================================================== #
# Простая альтернатива:
# head -c4 /dev/urandom| od -An -tu4
exit 0
</source> 
<big>'''tail'''</big> 
Выводит последние строки из файла на ''stdout'' (по-умолчанию — 10 строк). Обычно используется для мониторинга системных журналов. Ключ ''-f'', позволяет вести непрерывное наблюдение за добавляемыми строками в файл.
 '''Пример''': '''''Мониторинг системного журнала с помощью tail.'''''
<source lang="bash">
#!/bin/bash
filename=sys.log
cat /dev/null > $filename; echo "Создание / очистка временного файла."
# Если файл отсутствует, то он создаётся,
# и очищается, если существует.
# : > filename и > filename дают тот же эффект.
tail /var/log/messages > $filename
# Файл /var/log/messages должен быть доступен для чтения.
echo "В файл $filename записаны последние строки из /var/log/messages."
exit 0
</source> 
<big>'''grep'''</big> 
Многоцелевая поисковая утилита, использующая регулярные выражения. Изначально это была команда в древнем строчном редакторе ''ed'', g/re/p, что означает — ''global-regular expression-print''.
<source lang="bash">
grep pattern [file...]
</source> 
Поиск участков текста в файле(ах), соответствующих шаблону ''pattern'', где ''pattern'' может быть как обычной строкой, так и регулярным выражением.
<source lang="bash">
bash$ grep '[rst]ystem.$' osinfo.txt
The GPL governs the distribution of the Linux operating system.
</source> 
Если файл(ы) для поиска не задан, то команда [[grep]] работает как фильтр для устройства ''stdout'', например в конвейере.
<source lang="bash">
bash$ ps ax | grep clock
765 tty1 S 0:00 xclock
901 pts/1 S 0:00 grep clock
</source> 
'''''-i''''' — выполняется поиск без учёта регистра символов. 
'''''-w''''' — поиск совпадений целого слова. 
'''''-l''''' — вывод только имён файлов, в которых найдены участки, совпадающие с заданным образцом/шаблоном, без вывода совпадающих строк. 
'''''-r''''' — (рекурсивный поиск) поиск выполняется в текущем каталоге и всех вложенных подкаталогах. 
'''''-n''''' — отображает соответствующие строки вместе с номерами строк.
<source lang="bash">
bash$ grep -n Linux osinfo.txt
2:This is a file containing information about Linux.
6:The GPL governs the distribution of the Linux operating system.
</source>
'''''-v (или --invert-match)''''' — выводит только строки, не содержащие совпадений.
<source lang="bash">
grep pattern1 *.txt | grep -v pattern2
# Выводятся строки из "*.txt", совпадающие с "pattern1",
# но ***не*** совпадающие с "pattern2".
</source>
'''''-c (--count)''''' — выводит количество совпадений без вывода самих совпадений.
<source lang="bash">
grep -c txt *.sgml # (количество совпадений с "txt" в "*.sgml" файлах)
# grep -cz .
# ^ точка
# означает подсчет (-c) непустых ("." -- содержащих хотя бы один символ) элементов,
# разделённых нулевыми байтами (-z)
#
printf 'a b\nc d\n\n\n\n\n\000\n\000e\000\000\nf' | grep -cz . # 4
printf 'a b\nc d\n\n\n\n\n\000\n\000e\000\000\nf' | grep -cz '$' # 5
printf 'a b\nc d\n\n\n\n\n\000\n\000e\000\000\nf' | grep -cz '^' # 5
#
printf 'a b\nc d\n\n\n\n\n\000\n\000e\000\000\nf' | grep -c '$' # 9
# По-умолчанию, в качестве разделителя, принимается символ перевода строки (\n).
# Обратите внимание: ключ -z характерен для GNU-версии "grep".
# Спасибо S.C.
</source> 
Если [[grep]] вызывается для поиска по группе файлов, то вывод будет содержать указание на имена файлов, в которых найдены совпадения. 
<source lang="bash">
bash$ grep Linux osinfo.txt misc.txt
osinfo.txt:This is a file containing information about Linux.
osinfo.txt:The GPL governs the distribution of the Linux operating system.
misc.txt:The Linux operating system is steadily gaining in popularity.
</source> 
Для того, чтобы заставить [[grep]] выводить имя файла, когда поиск производится по одному-единственному файлу, достаточно указать устройство ''/dev/null'' в качестве второго файла.
<source lang="bash">
bash$ grep Linux osinfo.txt /dev/null
osinfo.txt:This is a file containing information about Linux.
osinfo.txt:The GPL governs the distribution of the Linux operating system.
</source> 
Если совпадение было найдено, то [[grep]] возвращает код завершения — 0, это может оказаться полезным при выполнении поиска в условных операторах ( в таких случаях особый интерес может представлять ключ ''-q'', который подавляет вывод).
<source lang="bash">
SUCCESS=0 # если найдено совпадение
word=Linux
filename=data.file
grep -q "$word" "$filename" # "-q" — подавляет вывод на stdout.
if [ $? -eq $SUCCESS ]
# if grep -q "$word" "$filename" эта комбинация может заменить строки 5 - 7.
then
echo "Образец $word найден в $filename"
else
echo "Образец $word в файле $filename не найден"
fi
</source> 
 '''Пример''': '''''Сценарий-эмулятор "grep".'''''
<source lang="bash">
#!/bin/bash
# grp.sh: Очень "грубая" реализация 'grep'.
E_BADARGS=65
if [ -z "$1" ] # Проверка наличия аргументов.
then
echo "Порядок использования: `basename $0` pattern"
exit $E_BADARGS
fi
echo
for file in * # Обход всех файлов в $PWD.
do
output=$(sed -n /"$1"/p $file) # Подстановка команд.
if [ ! -z "$output" ] # Что произойдет, если кавычки вокруг "$output" убрать?
then
echo -n "$file: "
echo $output
fi # эквивалент: sed -ne "/$1/s|^|${file}: |p"
echo
done
echo
exit 0
# Упражнения:
# ---------
# 1) Добавьте вывод символов перевода строки, если найдено более одного совпадения в любом из файлов.
# 2) Добавьте обработку различных ключей.
</source> 
'''''egrep''''' — то же самое, что и '''''grep -E'''''. Эта команда использует несколько отличающийся, расширенный набор регулярных выражений, что позволяет выполнять поиск более гибко. 
'''''fgrep''''' — то же самое, что и '''''grep -F'''''. Эта команда выполняет поиск строк символов (не регулярных выражений), что несколько увеличивает скорость поиска. 
Утилита '''''agrep''''' имеет более широкие возможности поиска приблизительных совпадений. Образец поиска может отличаться от найденой строки на указанное число символов. 
Для поиска по сжатым файлам следует использовать утилиты '''''zgrep''''', '''''zegrep''''' или '''''zfgrep'''''. Они с успехом могут использоваться и для не сжатых файлов, но в этом случае они уступают в скорости обычным '''''grep''''', '''''egrep''''' и '''''fgrep'''''. Они очень удобны при выполнении поиска по смешенному набору файлов — когда одни файлы сжаты, а другие нет. Для поиска по bzip-файлам используйте '''''bzgrep'''''. 
<big>'''look'''</big> 
Команда '''''look''''' очень похожа на [[grep]], и предназначена для поиска по "словарям" — отсортированным файлам. По-умолчанию, поиск выполняется в файле /usr/dict/words, но может быть указан и другой словарь.
 '''Пример''': '''''Поиск слов в словаре.'''''
<source lang="bash">
#!/bin/bash
# lookup: Выполняется поиск каждого слова из файла в словаре.
file=words.data # Файл с искомыми словами.
echo
while [ "$word" != end ] # Последнее слово в файле.
do
read word # Из файла, потому, что выполнено перенаправление в конце цикла.
look $word > /dev/null # Подавление вывода строк из словаря.
lookup=$? # Код возврата команды 'look'.
if [ "$lookup" -eq 0 ]
then
echo "Слово \"$word\" найдено."
else
echo "Слово \"$word\" не найдено."
fi
done <"$file" # Перенаправление ввода из файла $file, так что "чтение" производится оттуда.
echo
exit 0
# ----------------------------------------------------------------
# Строки, расположенные ниже не будут исполнены, поскольку выше стоит команда "exit".
# Stephane Chazelas предложил более короткий вариант:
while read word && [[ $word != end ]]
do if look "$word" > /dev/null
then echo "Слово \"$word\" найдено."
else echo "Слово \"$word\" не найдено."
fi
done <"$file"
exit 0
</source> 
<big>'''sed,awk'''</big> 
Скриптовые языки, специально разработанные для анализа текстовых данных.
[[sed]] — Неинтерактивный "потоковый редактор". Широко используется в сценариях на языке командной оболочки. 
[[awk]] — Утилита контекстного поиска и преобразования текста, замечательный инструмент для извлечения и/или обработки полей (колонок) в структурированных текстовых файлах. Синтаксис awk напоминает язык C. 
<big>'''wc'''</big> 
'''''wc''''' — "word count", счётчик слов в файле или в потоке:
<source lang="bash">
bash $ wc /usr/doc/sed-3.02/README
20 127 838 /usr/doc/sed-3.02/README
[20 строк 127 слов 838 символов]
</source> 
'''''wc -w''''' — подсчитывает только слова. 
'''''wc -l''''' — подсчитывает только строки. 
'''''wc -c''''' — подсчитывает только символы. 
'''''wc -L''''' — возвращает длину наибольшей строки. 
Подсчёт количества .txt-файлов в текущем каталоге с помощью '''''wc''''':
<source lang="bash">
$ ls *.txt | wc -l
# Эта команда будет работать, если ни в одном из имен файлов "*.txt" нет символа перевода строки.
# Альтернативный вариант:
# find . -maxdepth 1 -name \*.txt -print0 | grep -cz .
# (shopt -s nullglob; set -- *.txt; echo $#)

# Спасибо S.C.
</source> 
Подсчёт общего размера файлов, чьи имена начинаются с символов, в диапазоне ''d—h''
<source lang="bash">
bash$ wc [d-h]* | grep total | awk '{print $3}'
71832
</source> 
От переводчика: в случае, если у вас локаль отлична от "C", то вышеприведённая команда может не дать результата, поскольку '''''wc''''' вернёт не слово "total", в конце вывода, а "итого". Тогда можно попробовать несколько изменённый вариант:
<source lang="bash">
bash$ wc [d-h]* | grep итого | awk '{print $3}'
71832
</source> 
Использование '''''wc''''' для подсчёта количества вхождений слова "Linux" в основной исходный файл с текстом этого руководства.
<source lang="bash">
bash$ grep Linux abs-book.sgml | wc -l
50
</source> 
Отдельные команды располагают функциональностью '''''wc''''' в виде своих ключей.
Часто встречающаяся конструкция, которая может быть сокращена: 
<source lang="bash">... | grep foo | wc -l</source> 
Ключ ''-c'' (''--count'') команды [[grep]]. Спасибо S.C.: 
<source lang="bash">... | grep -c foo </source> 
<big>'''tr'''</big> 
Замена одних символов на другие. В отдельных случаях символы необходимо заключать в кавычки и/или квадратные скобки. Кавычки предотвращают интерпретацию специальных символов командной оболочкой. Квадратные скобки должны заключаться в кавычки.
Команда '''''tr "A-Z" "*" < filename''''' или '''''tr A-Z \* < filename''''' заменяет все символы верхнего регистра в ''filename'' на звёздочки (вывод производится на ''stdout''). В некоторых системах этот вариант может оказаться неработоспособным, тогда попробуйте ''''' tr A-Z '[**]' '''''. 
Ключ ''-d'' удаляет символы из заданного диапазона.
<source lang="bash">
echo "abcdef" # abcdef
echo "abcdef" | tr -d b-d # aef

tr -d 0-9 <filename # Удалит все цифровые символы из файла "filename".
</source> 
Ключ ''--squeeze-repeats'' (''-s'') удалит все повторяющиеся последовательности символов. Может использоваться для удаления лишних пробельных символов.
<source lang="bash">
bash$ echo "XXXXX" | tr --squeeze-repeats 'X'
X
</source> 
Ключ ''-c'' "complement" заменит символы в соответствии с шаблоном. Этот ключ воздействует только на те символы, которые НЕ соответствуют заданному шаблону.
<source lang="bash">
bash$ echo "acfdeb123" | tr -c b-d +
+c+d+b++++
</source> 
Обратите внимание: команда '''''tr''''' корректно распознает символьные классы POSIX. 
<source lang="bash">
bash$ echo "abcd2ef1" | tr '[:alpha:]' -
----2--1
</source> 
 '''Пример''': '''''toupper: Преобразование символов в верхний регистр.'''''
<source lang="bash">
#!/bin/bash
# Преобразование символов в верхний регистр.
E_BADARGS=65
if [ -z "$1" ] # Стандартная проверка командной строки.
then
echo "Порядок использования: `basename $0` filename"
exit $E_BADARGS
fi
tr a-z A-Z <"$1"
# Тот же эффект можно получить при использовании символьных классов POSIX:
# tr '[:lower:]' '[:upper:]' <"$1"
# Спасибо S.C.
exit 0
</source> 
 '''Пример''': '''''lowercase: Изменение имен всех файлов в текущем каталоге в нижний регистр.'''''
<source lang="bash">
#! /bin/bash
#
# Изменит все имена файлов в текущем каталоге в нижний регистр.
#
for filename in * # Обход всех файлов в каталоге.
do
fname=`basename $filename`
n=`echo $fname | tr A-Z a-z` # Перевести символы в нижний регистр.
if [ "$fname" != "$n" ] # Переименовать только те файлы, имена которых изменились.
then
mv $fname $n
fi
done
exit 0
# Строки приведённые ниже не будут исполняться, поскольку выше стоит команда "exit".
#--------------------------------------------------------#
# Запустите эту часть сценария, удалив строки , стоящие выше.
# Сценарий, приведенный выше, не работает с именами файлов, содержащими пробелы или символы перевода строки.
# В связи с этим, Stephane Chazelas предложил следующий вариант:
for filename in * # Нет необходимости использовать basename,
# поскольку "*" возвращает имена, не содержащие "/".
do n=`echo "$filename/" | tr '[:upper:]' '[:lower:]'`
# символьные классы POSIX.
# Завершающий слэш добавлен для того, чтобы символ перевода строки
# не был удален при подстановке команды.
# Подстановка переменной:
n=${n%/} # Удаление завершающего слэша, добавленного выше.
[[ $filename == $n ]] || mv "$filename" "$n"
# Проверка — действительно ли изменилось имя файла.
done
exit 0
</source> 
 '''Пример''': '''''du: Преобразование текстового файла из формата DOS в формат Unix.'''''
<source lang="bash">
#!/bin/bash
# du.sh: Преобразование текстового файла из формата DOS в формат UNIX.
E_WRONGARGS=65
if [ -z "$1" ]
then
echo "Порядок использования: `basename $0` filename-to-convert"
exit $E_WRONGARGS
fi
NEWFILENAME=$1.unxCR='\015' # Возврат каретки.
# 015 — это символ CR в восьмеричном формате
# Строки в текстовых файлах DOS завершаются комбинацией символов CR-LF.
tr -d $CR < $1 > $NEWFILENAME
# Удалить символы CR и записать в новый файл.
echo "Исходный текстовый файл: \"$1\"."
echo "Преобразованный файл: \"$NEWFILENAME\"."
exit 0
# Упражнение:
# --------
# Измените этот сценарий таким образом, чтобы он преобразовывал файлы из
# формата UNIX в формат DOS.
</source> 
 '''Пример''': '''''rot13: Сверхслабое шифрование по алгоритму rot13.'''''
<source lang="bash">
#!/bin/bash
# rot13.sh: Классический алгоритм шифрования rot13,
# который способен "расколоть" даже 3-х летний ребенок.
# Порядок использования: ./rot13.sh filename
# или ./rot13.sh <filename
# или ./rot13.sh и ввести текст с клавиатуры (stdin)
cat "$@" | tr 'a-zA-Z' 'n-za-mN-ZA-M' # "a" заменяется на "n", "b" на "o", и т.д.
# Конструкция 'cat "$@"'
# позволяет вводить данные как со stdin, так и из файла.
exit 0
</source> 
 '''Пример''': '''''Более "сложный" шифр'''''
<source lang="bash">
#!/bin/bash
# crypto-quote.sh: Ограниченное шифрование
# Шифрование ограничивается простой заменой одних алфавитных символов другими.
# Результат очень похож на шифры-загадки
key=ETAOINSHRDLUBCFGJMQPVWZYXK
# Здесь, "key" — ни что иное, как "перемешанный" алфавит.
# Изменение ключа "key" приведет к изменению шифра.
# Конструкция 'cat "$@"' позволяет вводить данные как со stdin, так и из файла.
# Если используется stdin, то ввод должен завершаться комбинацией Control-D.
# Иначе, в командной строке, сценарию должно быть передано имя файла.
cat "$@" | tr "a-z" "A-Z" | tr "A-Z" "$key"
# |в верхний регистр| шифрование
# Такой прием позволяет шифровать как символы в верхнем регистре, так и в нижнем.
# Неалфавитные символы остаются без изменений.

# Попробуйте зашифровать какой либо текст, например
# "Nothing so needs reforming as other people's habits." — Mark Twain
#
# Результат будет:
# "CFPHRCS QF CIIOQ MINFMBRCS EQ FPHIM GIFGUI'Q HETRPQ." — BEML PZERC
# Для дешифрации можно использовать следующую комбинацию:
# cat "$@" | tr "$key" "A-Z"
# Этот нехитрый шифр может быть "взломан" 12-ти летним ребёнком
# с помощью карандаша и бумаги.
exit 0
</source> 
{| class="wikitable"
|-
! Различные версии tr
|-
| Утилита '''''tr''''' имеет две, исторически сложившиеся, версии. BSD-версия не использует квадратные скобки (tr a-z A-Z), в то время как SysV-версия использует их (tr '[a-z]' '[A-Z]'). GNU-версия утилиты '''''tr''''' напоминает версию BSD, но диапазоны символов обязательно должны заключаться в квадратные скобки.
|}
<big>'''fold'''</big> 
Выравнивает текст по ширине, разрывая, если это необходимо, слова. Особый интерес представляет ключ ''-s'', который производит перенос строк по пробелам, стараясь не разрывать слова. 
<big>'''fmt'''</big> 
Очень простая утилита форматирования текста, чаще всего используемая как фильтр в конвейерах для того, чтобы выполнить "перенос" длинных строк текста.
 '''Пример''': '''''Отформатированный список файлов.'''''
<source lang="bash">
#!/bin/bash
WIDTH=40 # 40 символов в строке.
b=`ls /usr/local/bin` # Получить список файлов...
echo $b | fmt -w $WIDTH
# То же самое можно выполнить командой
# echo $b | fold - -s -w $WIDTH
exit 0
</source> 
Очень мощной альтернативой утилите '''''fmt''''', является утилита '''''par''''' (автор Kamil Toman), которую вы сможете найти на http://www.cs.berkeley.edu/~amc/Par/.
<big>'''col'''</big> 
Эта утилита с обманчивым названием удаляет из входного потока символы обратной подачи бумаги (код ESC 7). Она так же пытается заменить пробелы на табуляции. Основная область применения утилиты '''''col''''' — фильтрация вывода отдельных утилит обработки текста, таких как '''''groff''''' и '''''tbl'''''. 
<big>'''col'''</big> 
Форматирование по столбцам. Эта утилита преобразует текст, например какой либо список, в табличное, более "удобочитаемое", представление, вставляя символы табуляции по мере необходимости. 
 '''Пример''': '''''Пример форматирования списка файлов в каталоге.'''''
<source lang="bash">
#!/bin/bash
# За основу сценария взят пример "man column".
(printf "PERMISSIONS LINKS OWNER GROUP SIZE DATE TIME PROG-NAME\n" \
; ls -l | sed 1d) | column -t # Команда "sed 1d" удаляет первую строку, выводимую командой ls,
# (для локали "С" это строка: "total N", где "N" — общее количество файлов.
# Ключ -t, команды "column", означает "табличное" представление.
exit 0
</source> 
<big>'''colrm'''</big> 
Утилита удаления колонок. Удаляет колонки (столбцы) символов из файла и выводит результат на ''stdout''. 
'''''colrm 2 4 < filename''''' — удалит символы со 2-го по 4-й включительно, в каждой строке в файле filename. 
Если файл содержит символы табуляции или непечатаемые символы, то результат может получиться самым неожиданным. В таких случаях, как правило, утилиту '''''colrm''''', в конвейере, окружают командами '''''expand''''' и '''''unexpand'''''. 
<big>'''nl'''</big> 
Нумерует строки в файле. '''''nl filename''''' — выведет файл ''filename'' на ''stdout'', и в начале каждой строки вставит её порядковый номер, счёт начинается с первой непустой строки. Если файл не указывается, то принимается ввод со ''stdin''. Вывод команды '''''nl''''' очень напоминает '''''cat -n''''', однако, по-умолчанию '''''nl''''' не нумерует пустые строки.
 '''Пример''': '''''Самонумерующийся сценарий.'''''
<source lang="bash">
#!/bin/bash
# Сценарий выводит себя сам на stdout дважды, нумеруя строки сценария.
# 'nl' вставит для этой строки номер 3, поскольку она не нумерует пустые строки.
# 'cat -n' вставит для этой строки номер 5.
nl `basename $0`
echo; echo # А теперь попробуем вывести текст сценария с помощью 'cat -n'cat -n `basename $0`
# Различия состоят в том, что 'cat -n' нумерует все строки.
# Обратите внимание: 'nl -ba' — сделает то же самое.
exit 0
</source> 
<big>'''pr'''</big> 
Подготовка файла к печати. Утилита производит разбивку файла на страницы, приводя его в вид пригодный для печати или для вывода на экран. Разнообразные ключи позволяют выполнять различные манипуляции над строками и колонками, соединять строки, устанавливать поля, нумеровать строки, добавлять колонтитулы и многое, многое другое. Утилита '''''pr''''' соединяет в себе функциональность таких команд, как '''''nl''''', '''''paste''''', '''''fold''''', '''''column''''' и '''''expand'''''. 
Следующая команда выдаст хорошо оформленное и разбитое на страницы содержимое файла fileZZZ: 
<source lang="bash">pr -o 5 --width=65 fileZZZ | more </source> 
Хочу особо отметить ключ ''-d'', который выводит строки с двойным интервалом (тот же эффект,что и ''sed -G''). 
<big>'''gettext'''</big> 
GNU утилита, предназначена для нужд локализации и перевода сообщений программ, выводимых на экран, на язык пользователя. Не смотря на то, что это актуально, прежде всего,для программ на языке C, тем не менее '''''gettext''''' с успехом может использоваться в сценариях командной оболочки для тех же целей. 
<big>'''msgfmt'''</big> 
Эта утилита предназначена для создания двоичных файлов с переводом сообщений, выводимых перед пользователем. Используется для нужд локализации. 
<big>'''iconv'''</big> 
Утилита преобразования текста из одной кодировки в другую. В основном используется для нужд локализации. 
<big>'''recode'''</big> 
Может рассматриваться как разновидность утилиты '''''iconv''''', описанной выше. Универсальная утилита для преобразования текстовой информации в различные кодировки. 
<big>'''TeX,gs'''</big> 
'''''TeX''''' и '''''Postscript''''' — языки разметки текста, используемые для подготовки текста к печати или выводу на экран. 
'''''TeX''''' — это сложная система подготовки к печати, разработанная Дональдом Кнутом (Donald Knuth). Эту утилиту удобнее использовать внутри сценария, чем в командной строке, поскольку в сценарии проще один раз записать все необходимые параметры, передаваемые утилите, для получения необходимого результата. 
'''''Ghostscript''''' (gs) — это GPL-версия интерпретатора Postscript. 
<big>'''groff,tbl,eqn'''</big> 
'''''groff''''' — это ещё один язык разметки текста и форматированного вывода. Является расширенной GNU-версией пакета '''''roff'''''/'''''troff''''' в Unix-системах. 
'''''tbl''''' — утилита обработки таблиц, должна рассматриваться как составная часть '''''groff''''', так как её задачей является преобразование таблиц в команды '''''groff'''''. 
'''''eqn''''' — утилита преобразования математических выражений в команды '''''groff'''''. 
<big>'''lex,yacc'''</big> 
'''''lex''''' — утилита лексического разбора текста. В Linux-системах заменена на свободно распространяемую утилиту '''''flex'''''. 
'''''yacc''''' — утилита для создания синтаксических анализаторов, на основе набора грамматик, задаваемых разработчиком. В Linux-системах, эта утилита заменена на свободнораспространяемую утилиту '''''bison'''''.

=== Команды для работы с файлами и архивами ===
'''Архивация''' 
<big>'''tar'''</big> 
Стандартная, для Unix, утилита архивирования. Первоначально — это была программа ''TapeARchiving'', которая впоследствии переросла в универсальный пакет, который может работать с любыми типами устройств. В GNU-версию [[tar]] была добавлена возможность одновременно производить сжатие tar-архива, например команда '''''tar czvf archive_name.tar.gz*''''' создаёт tar-архив дерева подкаталогов и вызывает [[gzip]] для выполнения сжатия, исключение составляют скрытые файлы в текущем каталоге (<big>$PWD</big>). 
Некоторые, часто используемые, ключи команды [[tar]]: 
# '''''-c''''' — создать (''create'') новый архив
# '''''-x''''' — извлечь (''extract'') файлы из архива
# '''''--delete''''' — удалить (''delete'') файлы из архива. Этот ключ игнорируется для накопителей на магнитной ленте.
# '''''-r''''' — добавить (''append'') файлы в существующий архив
# '''''-A''''' — добавить (''append'') tar-файлы в существующий архив
# '''''-t''''' — список файлов в архиве (содержимое архива)
# '''''-u''''' — обновить (''update'') архив
# '''''-d''''' — операция сравнения архива с заданной файловой системой
# '''''-z''''' — обработка архива с помощью [[gzip]]. Сжатие или разжатие, в зависимости от комбинации сопутствующих ключей ''-c'' или ''-x''
# '''''-j''''' — обработка архива с помощью [[bzip2]] 
При восстановлении "битых" tar.gz архивов могут возникнуть определённые сложности, поэтому делайте несколько резервных копий.
<big>'''shar'''</big> 
Утилита создания shell-архива. Архивируемые файлы объединяются в единый файл без выполнения сжатия, в результате получается архив — по сути полноценный сценарий на языке командной оболочки, начинающийся со строки '''''#!/bin/sh''''', который содержит полный набор команд, необходимый для разархивирования. Такого рода архивы до сих пор можно найти в некоторых телеконференциях в Internet, но в последнее время они активно вытесняются связкой [[tar]]/[[gzip]]. Для распаковки shar-архивов предназначена команда unshar. 
<big>'''ar'''</big> 
Утилита создания и обслуживания архивов, главным образом применяется к двоичным файлам библиотек. 
<big>'''rpm'''</big> 
Red Hat Package Manager, или [[rpm]] — набор утилит, предназначенных для построения и обслуживания пакетов программного обеспечения как в исходном коде, так и в собранном(откомпилированном) виде. Среди всего прочего, включает в себя утилиты, производящие установку ПО, проверку зависимостей пакетов и проверку их целостности. 
Самый простой вариант установки ПО из [[rpm]] — выполнить команду '''''rpm -ipackage_name.rpm'''''. Команда '''''rpm -qa''''' выдаст полный список всех установленных rpm-пакетов в данной системе. Команда '''''rpm -qa package_name''''' выведет только пакет(ы) с именем, содержащим комбинацию символов ''package_name''.
<source lang="bash">
bash$ rpm -qa
redhat-logos-1.1.3-1
glibc-2.2.4-13
cracklib-2.7-12
dosfstools-2.7-1
gdbm-1.8.0-10
ksymoops-2.4.1-1
mktemp-1.5-11
perl-5.6.0-17
reiserfs-utils-3.x.0j-2
...
</source>
<source lang="bash">
bash$ rpm -qa docbook-utils
docbook-utils-0.6.9-2
bash$ rpm -qa docbook | grep docbook
docbook-dtd31-sgml-1.0-10
docbook-style-dsssl-1.64-3
docbook-dtd30-sgml-1.0-10
docbook-dtd40-sgml-1.0-11
docbook-utils-pdf-0.6.9-2
docbook-dtd41-sgml-1.0-10
docbook-utils-0.6.9-2
</source>
<big>'''cpio'''</big> 
Специализированная утилита архивации и копирования (''copy input and output''). Используется всё реже и реже, поскольку вытесняется более мощным архиватором [[tar]]/[[gzip]]. Наиболее употребительна для таких операций, как перемещение дерева каталогов. 
 '''Пример''': '''''Пример перемещения дерева каталогов с помощью cpio.'''''
<source lang="bash">
#!/bin/bash
# Копирование дерева каталогов с помощью cpio.
ARGS=2
E_BADARGS=65
if [ $# -ne "$ARGS" ]
then
echo "Порядок использования: `basename $0` source destination"
exit $E_BADARGS
fi
source=$1
destination=$2
find "$source" -depth | cpio -admvp "$destination"
# Информацию по ключам утилиты cpio вы найдете в страницах руководства "man cpio".
exit 0
</source>
<big>'''rpm2cpio'''</big> 
Эта утилита конвертирует rpm-пакет в архив cpio.
 '''Пример''': '''''Распаковка архива rpm.'''''
<source lang="bash">
#!/bin/bash
# de-rpm.sh: Распаковка архива 'rpm'
: ${1?"Порядок использования: `basename $0` target-file"}
# Сценарию должно быть передано имя архива 'rpm'.
TEMPFILE=$$.cpio # Временный файл с "уникальным" именем.
# $$ — PID процесса сценария.
rpm2cpio < $1 > $TEMPFILE # Конверсия из rpm в cpio.
cpio --make-directories -F $TEMPFILE -i # Распаковка cpio-архива.
rm -f $TEMPFILE # Удаление cpio-архива.
exit 0
# Упражнение:
# Добавьте проверку на:
# 1) Существование "target-file"
# 2) Действительно ли "target-file" является rpm-архивом.
# Подсказка: используйте команду 'file'.
</source>
'''Сжатие''' 
<big>'''gzip'''</big> 
Стандартная GNU/Unix утилита сжатия, заменившая более слабую, и к тому же проприетарную, утилиту ''compress''. Соответствующая утилита декомпрессии (разжатия) — gunzip, которая является эквивалентом команды ''[[gzip]] -d''. 
Для работы со сжатыми файлами в конвейере используется фильтр ''zcat'', который выводит результат своей работы на ''stdout'', допускает перенаправление вывода. Фактически это та же команда [[cat]], только приспособленная для работы со сжатыми файлами (включая файлы, сжатые утилитой ''compress''). Эквивалент команды ''zcat'' — ''[[gzip]] -dc''. 
В некоторых коммерческих версиях Unix, команда ''zcat'' является синонимом команды ''uncompress -c'', и не может работать с файлами, сжатыми с помощью [[gzip]]. 
<big>'''bzip2'''</big> 
Альтернативная утилита сжатия, обычно даёт более высокую степень сжатия (но при этом работает медленнее), чем [[gzip]], особенно это проявляется на больших файлах. Соответствующая утилита декомпрессии — ''bunzip2''. В современные версии [[tar]] добавлена поддержка [[bzip2]]. 
<big>'''compress,uncompress'''</big> 
Устаревшие проприетарные утилиты для работы с архивами, входящие в состав некоторых коммерческих дистрибутивов Unix. В последнее время вытесняются более мощной утилитой [[gzip]]. Linux-дистрибутивы, как правило, включают в свой состав эти утилиты для обратной совместимости, однако ''gunzip'' корректно разархивирует файлы, обработанные с помощью compress. Утилита ''znew'' предназначена для преобразования compress-архивов в gzip-архивы. 
<big>'''sq'''</big> 
Ещё одна утилита-фильтр сжатия, которая обслуживает только отсортированные списки слов. Использует стандартный, для фильтров, синтаксис вызова — '''''sq < input-file > output-file'''''. Быстрая, но не такая эффективная как [[gzip]]. Соответствующая ей утилита декомпрессии называется ''unsq'', синтаксис вызова аналогичен утилите ''sq''. 
Вывод от ''sq'' может быть передан по конвейеру утилите [[gzip]], для дальнейшего сжатия. 
<big>'''zip,unzip'''</big> 
Кроссплатформенная утилита архивирования и сжатия, совместимая, по формату архивного файла, с утилитой DOS — ''pkzip.exe''. "Zip"-архивы, по-моему, более приемлемый вариант для обмена данными через Internet, чем "tarballs" (тарболлы, или tar-архивы). 
<big>'''unarc,unarj,unrar'''</big> 
Этот набор утилит предназначен для распаковки архивов, созданных с помощью DOS-архиваторов — ''arc.exe'', ''arj.exe'' и ''rar.exe''. 
'''Получение сведений о файлах''' 
<big>'''file'''</big> 
Утилита идентификации файлов. Команда '''''file''''' ''filename'' вернёт тип файла ''filename'', например, ''ascii'', ''text'' или ''data''. Для этого она анализирует сигнатуру, или магическое число и сопоставляет её со списком известных сигнатур из ''/usr/share/magic'', ''/etc/magic'' или ''/usr/lib/magic'' (в зависимости от дистрибутива Linux/Unix). 
'''''-f''''' — ключ пакетного режима работы утилиты ''file'', в этом случае утилита принимает список анализируемых имён файлов из заданного файла. Ключ '''''-z''''' используется для анализа файлов в архиве.
<source lang="bash">
bash$ file test.tar.gz
test.tar.gz: gzip compressed data, deflated, last modified: Sun Sep 16 13:34:51 2001, os:
Unix
bash file -z test.tar.gz
test.tar.gz: GNU tar archive (gzip compressed data, deflated, last modified: Sun Sep 16 13:34:51 2001, os: Unix)
</source>
 '''Пример''': '''''Удаление комментариев из файла с текстом программы на языке C.'''''
<source lang="bash">
#!/bin/bash
# strip-comment.sh: Удаление комментариев (/* COMMENT */) из исходных текстов программ на языке C.
E_NOARGS=65
E_ARGERROR=66
E_WRONG_FILE_TYPE=67
if [ $# -eq "$E_NOARGS" ]
then
echo "Порядок использования: `basename $0` C-program-file" >&2 # Вывод сообщения на stderr.
exit $E_ARGERROR
fi
# Проверка типа файла.
type=`eval file $1 | awk '{ print $2, $3, $4, $5 }'`
# "file $1" — выводит тип файла...
# затем awk удаляет первое поле — имя файла...
# после этого результат записывается в переменную "type".
correct_type="ASCII C program text"

if [ "$type" != "$correct_type" ]
then
echo
echo "Этот сценарий работает только с исходными текстами программ на языке C."
echo
exit $E_WRONG_FILE_TYPE
fi

# Довольно замысловатый сценарий sed :
#--------
sed '
/^\/\*/d
/.*\/\*/d
' $1
#--------
# Если вы потратите несколько часов на изучение основ sed, то он станет немного понятнее.
# Следовало бы добавить ещё обработку
# комментариев, расположенных в одной строке с кодом.
# Оставляю это вам, в качестве упражнения.
# Кроме того, этот сценарий удалит все строки, которые содержат комбинации символов "*/" или "/*",
# не всегда желаемый результат.
exit 0
# ----------------------------------------------------------------
# Строки, расположенные ниже не будут исполнены из-за стоящей выше команды 'exit 0'.
# Stephane Chazelas предложил другой, альтернативный вариант:
usage() {
echo "Порядок использования: `basename $0` C-program-file" >&2
exit 1
}
WEIRD=`echo -n -e '\377'` # или WEIRD=$'\377'
[[ $# -eq 1 ]] || usage
case `file "$1"` in
*"C program text"*) sed -e "s%/\*%${WEIRD}%g;s%\*/%${WEIRD}%g" "$1" \
| tr '\377\n' '\n\377' \
| sed -ne 'p;n' \
| tr -d '\n' | tr '\377' '\n';;
*) usage;;
esac
# Этот вариант, все ещё некорректно обрабатывает такие строки как:
# printf("/*");
# или
# /* /* ошибочный вложенный комментарий */
#
# Для обработки специальных случаев (\", \\" ...) придется написать синтаксический анализатор
# (может быть с помощью lex или yacc?).
exit 0
</source>
<big>'''which'''</big> 
Команда '''''which command-xxx''''' вернёт полный путь к ''command-xx''. Очень полезна для того,чтобы узнать — установлена ли та или иная утилита в системе.
<source lang="bash">
$bash which rm
/usr/bin/rm
</source>
<big>'''whereis'''</big> 
Очень похожа на ''which'', упоминавшуюся выше. Команда ''whereis'' command-xxx вернёт полный путь к "command-xxx", но кроме того, ещё и путь к manpage — файлу, странице справочника по заданной утилите.
<source lang="bash">
$bash whereis rm
rm: /bin/rm /usr/share/man/man1/rm.1.bz2
</source>
<big>'''whatis'''</big> 
Утилита '''''whatis filexxx''''' отыщет "filexxx" в своей базе данных. Может рассматриваться как упрощённый вариант команды ''man''.
<source lang="bash">
$bash whatis whatis
whatis (1) - search the whatis database for complete words
</source>
 '''Пример''': '''''Исследование каталога /usr/X11R6/bin.'''''
<source lang="bash">
#!/bin/bash
# Что находится в каталоге /usr/X11R6/bin?
DIRECTORY="/usr/X11R6/bin"
# Попробуйте также "/bin", "/usr/bin", "/usr/local/bin", и т.д.
for file in $DIRECTORY/*
do
whatis `basename $file` # Вывод информации о файле.
done
exit 0
# Вывод этого сценария можно перенаправить в файл:
# ./what.sh >>whatis.db
# или включить постраничный просмотр на экране,
# ./what.sh | less
</source>
<big>'''vdir'''</big> 
Вывод списка файлов в каталоге. Тот же эффект имеет команда ''[[ls]] -l'' 
Это одна из утилит GNU fileutils.
<source lang="bash">
bash$ vdir
total 10
-rw-r--r-- 1 bozo bozo 4034 Jul 18 22:04 data1.xrolo
-rw-r--r-- 1 bozo bozo 4602 May 25 13:58 data1.xrolo.bak
-rw-r--r-- 1 bozo bozo 877 Dec 17 2000 employment.xrolo
bash ls -l
total 10
-rw-r--r-- 1 bozo bozo 4034 Jul 18 22:04 data1.xrolo
-rw-r--r-- 1 bozo bozo 4602 May 25 13:58 data1.xrolo.bak
-rw-r--r-- 1 bozo bozo 877 Dec 17 2000 employment.xrolo
</source>
<big>'''locate,slocate'''</big> 
Команда ''locate'' определяет местонахождение файла, используя свою базу данных, создаваемую специально для этих целей. Команда ''slocate'' — это защищенная версия ''locate'' (которая может оказаться простым псевдонимом команды ''slocate'').
<source lang="bash">
$bash locate hickson
/usr/lib/xephem/catalogs/hickson.edb
</source>
<big>'''readlink'''</big> 
Возвращает имя файла, на который указывает символическая ссылка. 
<source lang="bash">
bash$ readlink /usr/bin/awk
../../bin/gawk
</source>
<big>'''strings'''</big> 
Команда '''''strings''''' используется для поиска печатаемых строк в двоичных файлах. Она выводит последовательности печатаемых символов, обнаруженных в заданном файле. Может использоваться для прикидочного анализа дамп-файлов (core dump) или для отыскания информации о типе файла, например для графических файлов неизвестного формата(например, '''''strings image-file | more''''' может вывести такую строчку: JFIF, что говорит о том, что мы имеем дело с графическим файлом в формате jpeg). В сценариях, вероятнее всего, вам придётся использовать эту команду в связке с [[grep]] или [[sed]].
 '''Пример''': '''''"Расширенная" команда strings.'''''
<source lang="bash">
#!/bin/bash
# wstrings.sh: "word-strings" (расширенная команда "strings")
#
# Этот сценарий фильтрует вывод команды "strings" путем проверки на соответствие
# выводимых слов по файлу словаря.
# Таким способом эффективно "отсекается" весь "мусор",
# и выводятся только распознанные слова.
# =================================================================
# Стандартная проверка входных аргументов
ARGS=1
E_BADARGS=65
E_NOFILE=66
if [ $# -ne $ARGS ]
then
echo "Порядок использования: `basename $0` filename"
exit $E_BADARGS
fi
if [ ! -f "$1" ] # Проверка наличия файла.
then
echo "Файл \"$1\" не найден."
exit $E_NOFILE
fi
# =================================================================
MINSTRLEN=3 # Минимальная длина строки.
WORDFILE=/usr/share/dict/linux.words # Файл словаря.
# Можно указать иной
# файл словаря
# в формате — "одно слово на строке".
wlist=`strings "$1" | tr A-Z a-z | tr '[:space:]' Z | \
tr -cs '[:alpha:]' Z | tr -s '\173-\377' Z | tr Z ' '`
# Трансляция вывода от 'strings' с помощью нескольких 'tr'.
# "tr A-Z a-z" — перевод в нижний регистр.
# "tr '[:space:]'" — конвертирует пробелы в символы Z.
# "tr -cs '[:alpha:]' Z" — конвертирует неалфавитные символы в символы Z,
# и удаляет повторяющиеся символы Z.
# "tr -s '\173-\377' Z" — Конвертирует все символы, с кодами выше 'z' в Z
# и удаляет повторяющиеся символы Z,
# эта команда удалит все символы, которые не были распознаны предыдущими
# командами трансляции (tr).
# Наконец, "tr Z ' '" — преобразует все символы Z в пробелы,
# которые будут рассматриваться в качестве разделителя слов в цикле, приведенном ниже.

# Обратите внимание на технику многоуровневой обработки с помощью 'tr',
# каждый раз эта команда вызывается с различным набором аргументов.
for word in $wlist # Важно:
# переменная $wlist не должна заключаться в кавычки.
# "$wlist" — не сработает.
# Почему?
do
strlen=${#word} # Дина строки.
if [ "$strlen" -lt "$MINSTRLEN" ] # Не рассматривать короткие строки.
then
continue
fi
grep -Fw $word "$WORDFILE" # Проверка слова по словарю.
done
exit 0
</source> 
'''Сравнение''' 
<big>'''diff,patch'''</big> 
'''''diff''''': очень гибкая утилита сравнения файлов. Она выполняет построчное сравнение файлов. В отдельных случаях, таких как поиск по словарю, может оказаться полезной фильтрация файлов с помощью '''''sort''''' и '''''uniq''''' перед тем как отдать поток данных через конвейер утилите '''''diff'''''. '''''diff file-1 file-2''''' — выведет строки, имеющие отличия, указывая — какому файлу, какая строка принадлежит. 
С ключом ''--side-by-side'', команда '''''diff''''' выведет сравниваемые файлы в две колонки, с указанием несовпадающих строк. Ключи ''-c'' и ''-u'' так же служат для облегчения интерпретации результатов работы '''''diff'''''. Существует ряд интерфейсных оболочек для утилиты '''''diff''''', среди них можно назвать: '''''spiff''''', '''''wdiff''''','''''xdiff ''''' и '''''mgdiff'''''. Команда '''''diff''''' возвращает код завершения 0, если сравниваемые файлы идентичны и 1, если они отличаются. Это позволяет использовать '''''diff''''' в условных операторах внутри сценариев на языке командной оболочки (см.ниже). 
В общем случае, '''''diff''''' используется для генерации файла различий, который используется как аргумент команды '''''patch'''''. Ключ ''-e'' отвечает за вывод файла различий в формате, пригодном для использования с '''''ed''''' или '''''ex'''''. 
'''''patch''''': гибкая утилита для "наложения заплат". С помощью файла различий, сгенерированного утилитой '''''diff''''', утилита '''''patch''''' может использоваться для обновления устаревших версий файлов. Это позволяет распространять относительно небольшие "diff"-файлы вместо целых пакетов. Распространение "заплат" к ядру стало наиболее предпочтительным методом распространения более новых версий ядра Linux.
<source lang="bash">
patch -p1 < patch-file
# Применит все изменения из 'patch-file'
# к файлам, описанным там же.
# Так выполняется обновление пакетов до более высоких версий.
</source>
Наложение "заплат" на ядро:
<source lang="bash">
cd /usr/src
gzip -cd patchXX.gz | patch -p0
# Обновление исходных текстов ядра с помощью 'patch'.
# Пример взят из файла "README",
# автор не известен (Alan Cox?).
</source>
Кроме того, утилита '''''diff''''' в состоянии выполнять рекурсивный обход каталогов.
<source lang="bash">
bash$ diff -r ~/notes1 ~/notes2
Only in /home/bozo/notes1: file02
Only in /home/bozo/notes1: file03
Only in /home/bozo/notes2: file04
</source>
Утилита '''''zdiff''''' сравнивает сжатые, с помощью [[gzip]], файлы. 
<big>'''diff3'''</big> 
Расширенная версия '''''diff''''', которая сравнивает сразу 3 файла. В случае успеха возвращает 0, но,к сожалению, не даёт никакой информации о результатах сравнения.
<source lang="bash">
bash$ diff3 file-1 file-2 file-3
====
1:1c
This is line 1 of "file-1".
2:1c
This is line 1 of "file-2".
3:1c
This is line 1 of "file-3"
</source>
<big>'''sdiff'''</big> 
Сравнение и/или редактирование двух файлов перед объединением их в один файл. Это интерактивная утилита, по своей природе, и из-за этого она довольно редко используется в сценариях. 
<big>'''cmp'''</big> 
Утилита '''''cmp''''' — это упрощенная версия '''''diff'''''. В то время, как '''''diff''''' выводит подробную информацию об имеющихся различиях, утилита '''''cmp''''' лишь показывает номер строки и позицию в строке, где было встречено различие. Подобно команде '''''diff''''', команда '''''cmp''''' возвращает код завершения 0, если файлы идентичны и 1, если они различны. Это позволяет использовать команду '''''cmp''''' в условных операторах.
 '''Пример''': '''''Пример сравнения двух файлов с помощью cmp.'''''
<source lang="bash">
#!/bin/bash
ARGS=2 # Ожидаются два аргумента командной строки.
E_BADARGS=65
E_UNREADABLE=66
if [ $# -ne "$ARGS" ]
then
echo "Порядок использования: `basename $0` file1 file2"
exit $E_BADARGS
fi
if [[ ! -r "$1" || ! -r "$2" ]]
then
echo "Оба файла должны существовать и должны быть доступны для чтения."
exit $E_UNREADABLE
fi
cmp $1 $2 &> /dev/null # /dev/null — "похоронит" вывод от команды "cmp".
# cmp -s $1 $2 даст тот же результат ("-s" — флаг "тишины" для "cmp")
# Спасибо Anders Gustavsson за замечание.
#
# Также применимо к 'diff', т.е., diff $1 $2 &> /dev/null
if [ $? -eq 0 ] # Проверка кода возврата команды "cmp".
then
echo "Файл \"$1\" идентичен файлу \"$2\"."
else
echo "Файл \"$1\" отличается от файла \"$2\"."
fi
exit 0
</source>
Для работы с [[gzip]] файлами используется утилита '''''zcmp'''''. 
<big>'''comm'''</big> 
Универсальная утилита сравнения. Работает с отсортированными файлами.
<source lang="bash">comm -options first-file second-file</source> 
<source lang="bash">comm file-1 file-2</source>
вывод в три колонки:
* колонка 1 = уникальные строки для file-1
* колонка 2 = уникальные строки для file-2
* колонка 3 = одинаковые строки.
Ключи, подавляющие вывод в одной или более колонках: 
* '''''-1''''' — подавление вывода в колонку 1
* '''''-2''''' — подавление вывода в колонку 2
* '''''-3''''' — подавление вывода в колонку 3
* '''''-12''''' — подавление вывода в колонки 1 и 2, и т.д. 
'''Утилиты''' 
<big>'''basename'''</big> 
Выводит только название файла, без каталога размещения. Конструкция '''''basename $0''''' — позволяет сценарию узнать свое имя, то есть имя файла, который был запущен. Это имя может быть использовано для вывода сообщений, например: 
<source lang="bash">echo "Порядок использования: `basename $0` arg1 arg2 ... argn"</source>
<big>'''dirname'''</big> 
Отсекает '''''basename''''' от полного имени файла и выводит только путь к файлу.
Утилитам '''''basename''''' и '''''dirname''''' может быть передана любая строка, в качестве аргумента. Этот аргумент необязательно должен быть именем существующего файла. 
 '''Пример''': '''''Утилиты basename и dirname.'''''
<source lang="bash">
#!/bin/bash
a=/home/bozo/daily-journal.txt
echo "Basename для /home/bozo/daily-journal.txt = `basename $a`"
echo "Dirname для /home/bozo/daily-journal.txt = `dirname $a`"
echo
echo "Мой домашний каталог `basename ~/`." # Можно указать просто ~.
echo "Каталог моего домашнего каталога `dirname ~/`." # Можно указать просто ~.
exit 0
</source>
<big>'''split'''</big> 
Утилита разбивает файл на несколько частей. Обычно используется для разбиения больших файлов, чтобы их можно было записать на дискеты или передать по электронной почте по частям. 
<big>'''sum,cksum,md5sum'''</big> 
Эти утилиты предназначены для вычисления контрольных сумм. Контрольная сумма — это некоторое число, вычисляемое исходя из содержимого файла, и служит для контроля целостности информации в файле. Сценарий может выполнять проверку контрольных сумм для того, чтобы убедиться, что файл не был изменен или повреждён. Для большей безопасности, рекомендуется использовать 128-битную сумму, генерируемую утилитой '''''md5sum''''' (''messagedigest checksum'').
<source lang="bash">
bash$ cksum /boot/vmlinuz
1670054224 804083 /boot/vmlinuz
bash$ md5sum /boot/vmlinuz
0f43eccea8f09e0a0b2b5cf1dcf333ba /boot/vmlinuz
</source>
Обратите внимание: утилита '''''cksum''''' выводит контрольную сумму и размер файла в байтах.
 '''Пример''': '''''Проверка целостности файла.'''''
<source lang="bash">
#!/bin/bash
# file-integrity.sh: Проверка целостности файлов в заданном каталоге
E_DIR_NOMATCH=70
E_BAD_DBFILE=71
dbfile=File_record.md5
# Файл для хранения контрольных сумм.
set_up_database ()
{
echo ""$directory"" > "$dbfile"
# Записать название каталога в первую строку файла.
md5sum "$directory"/* >> "$dbfile"
# Записать контрольные суммы md5 и имена файлов.
}
check_database ()
{
local n=0
local filename
local checksum
# ------------------------------------------- #
# Возможно эта проверка и не нужна,
# но лучше перестраховаться сейчас, чем жалеть об этом потом.
if [ ! -r "$dbfile" ]
then
echo "Не могу прочитать файл с контрольными суммами!"
exit $E_BAD_DBFILE
fi
# ------------------------------------------- #
while read record[n]
do
directory_checked="${record[0]}"
if [ "$directory_checked" != "$directory" ]
then
echo "Имя каталога не совпадает с записаным в файле!"
# Попытка использовать файл контрольных сумм для другого каталога.
exit $E_DIR_NOMATCH
fi
if [ "$n" -gt 0 ] # Не имя каталога.
then
filename[n]=$( echo ${record[$n]} | awk '{ print $2 }' )
# md5sum записывает в обратном порядке,
# сначала контрольную сумму, затем имя файла.
checksum[n]=$( md5sum "${filename[n]}" )
if [ "${record[n]}" = "${checksum[n]}" ]
then
echo "Файл ${filename[n]} не был изменен."
else
echo "ОШИБКА КОНТРОЛЬНОЙ СУММЫ для файла ${filename[n]}!"
# Файл был изменен со времени последней проверки.
fi
fi
let "n+=1"
done <"$dbfile" # Чтение контрольных сумм из файла.
}
# =================================================== #
# main ()
if [ -z "$1" ]
then
directory="$PWD" # Если каталог не задан,
else # то используется текущий каталог.
directory="$1"
fi
clear
# Очистка экрана.
# ------------------------------------------------------------------ #
if [ ! -r "$dbfile" ] # Необходимо создать файл с контрольными суммами?
then
echo "Создание файла с контрольными суммами, \""$directory"/"$dbfile"\"."; echo
set_up_database
fi
# ------------------------------------------------------------------ #
check_database # Выполнить проверку.
echo
# Вывод этого сценария можно перенаправить в файл,
# это особенно полезно при проверке большого количества файлов.
# Более строгая проверка целостности файлов,
# может быть выполнена с помощью пакета "Tripwire",
# http://sourceforge.net/projects/tripwire/.
exit 0
</source>
<big>'''shred'''</big> 
Надёжное, с точки зрения безопасности, стирание файла, посредством предварительной, многократной записи в файл случайной информации, перед тем как удалить его. Является составной частью пакета ''GNU fileutils''. Имеется ряд технологий, с помощью которых всё-таки возможно восстановить файлы, удаленные утилитой '''''shred'''''. 
'''Кодирование и шифрование''' 
<big>'''uuencode'''</big> 
Эта утилита используется для кодирования двоичных файлов в символы ASCII, после такого кодирования файлы могут, с достаточной степенью безопасности, передаваться по сети, вкладываться в электронные письма и т.п.. 
<big>'''uudecode'''</big> 
Утилита декодирования файлов, прошедших обработку утилитой '''''uuencode'''''. 
 '''Пример''': '''''Декодирование файлов.'''''
<source lang="bash">
#!/bin/bash
lines=35 # 35 строк для заголовка (более чем достаточно).
for File in * # Обход всех файлов в текущем каталоге...
do
search1=`head -$lines $File | grep begin | wc -w`
search2=`tail -$lines $File | grep end | wc -w`
# Закодированные файлы начинаются со слова "begin",
# и заканчиваются словом "end".
if [ "$search1" -gt 0 ]
then
if [ "$search2" -gt 0 ]
then
echo "декодируется файл - $File -"
uudecode $File
fi
fi
done
# Обратите внимание: если передать сценарию самого себя, для декодирования,
# то это введёт его в заблуждение поскольку в тексте сценария встречаются слова "begin" и "end".
exit 0
</source>
При декодировании и выводе длинных текстовых сообщений из новостных групп ''Usenet'', очень нелишним будет передать текст, по конвейеру, команде '''''fold -s'''''. 
<big>'''mimencode,mmencode'''</big> 
Утилиты '''''mimencode''''' и '''''mmencode''''' предназначены для обработки закодированных мультимедийных вложений в электронные письма. Хотя почтовые программы (такие как pine или kmail) имеют возможность автоматической обработки таких вложений, тем не менее эти утилиты позволяют обрабатывать вложения вручную, из командной строки или в пакетном режиме, из сценария на языке командной оболочки. 
<big>'''crypt'''</big> 
Одно время, это была стандартная, для Unix, утилита шифрования файлов. Политически мотивированные, правительственные постановления ряда стран, напрямую запрещают экспорт программного обеспечения для шифрования, что, в результате, привело практически к полному исчезновению '''''crypt''''' из большинства Unix-систем (в том числе и Linux). К счастью,программистами было разработано множество вполне приличных альтернатив, и среди них '''''cruft'''''. 
'''Прочее''' 
<big>'''mktemp'''</big> 
Создаёт временный файл с "уникальным" именем.
<source lang="bash">
PREFIX=filename
tempfile=`mktemp $PREFIX.XXXXXX`
# ^^^^^^ Необходимо по меньшей мере 6 заполнителейecho "имя временного файла = $tempfile"
echo "имя временного файла = $tempfile"
# имя временного файла = filename.QA2ZpY или нечто подобное...
</source> 
<big>'''make'''</big> 
Утилита для компиляции и сборки программ. Но может использоваться для выполнения любых других операций, основанных на анализе наличия изменений в исходных файлах. Команда '''''make''''' использует в своей работе Makefile, который содержит перечень зависимостей и операций, которые необходимо выполнить для удовлетворения этих зависимостей. 
<big>'''install'''</big> 
Своего рода — утилита копирования файлов, похожа на ''cp'', но дополнительно позволяет изменять права доступа и атрибуты копируемых файлов. Напрямую эта команда практически не используется, чаще всего она встречается в Makefile (в разделе ''make install'' :). Она может использоваться в сценариях установки ПО. 
<big>'''dos2unix'''</big> 
Автор утилиты — Benjamin Lin со-товарищи. Предназначена для преобразования текстовых файлов из формата DOS (в котором строки завершаются комбинацией символов CR-LF) в формат Unix (в котором строки завершаются одним символом LF) и обратно. 
<big>'''ptx'''</big> 
Команда '''''ptx [targetfile]''''' выводит a упорядоченный предметный указатель для ''targetfile'', который можно обработать, по мере необходимости, какой-либо утилитой форматирования, в конвейере. 
<big>'''more,less'''</big> 
Команды постраничного просмотра текстовых файлов или потоков на ''stdout''. Могут использоваться в сценариях в качестве фильтров.

=== Команды для работы с сетью ===
Команды, описываемые в этом разделе, могут найти применение при исследовании и анализе процессов передачи данных по сети, а также могут использоваться в борьбе со спамерами.
'''Информация и статистика''' 
<big>'''host'''</big> 
Возвращает информацию об узле Интернета, по заданному имени или IP адресу, выполняя поиск с помощью службы DNS.
<source lang="bash">
bash$ host surfacemail.com
surfacemail.com. has address 202.92.42.236
</source> 
<big>'''ipcalc'''</big> 
Выводит информацию о заданном узле сети. С ключом ''-h'', '''''ipcalc''''' выполняет поиск имени хоста в DNS, по заданному IP адресу.
<source lang="bash">
bash$ ipcalc -h 202.92.42.236
HOSTNAME=surfacemail.com
</source> 
<big>'''nslookup'''</big> 
Выполняет "поиск имени узла" Интернета по заданному IP адресу. По сути, эквивалентна командам '''''ipcalc -h''''' и '''''dig -x'''''. Команда может исполняться как в интерактивном, так и в неинтерактивном режиме, т.е. в пределах сценария.
<source lang="bash">
bash$ nslookup -sil 66.97.104.180
nslookup kuhleersparnis.ch
Server: 135.116.137.2
Address: 135.116.137.2#53
Non-authoritative answer:
Name: kuhleersparnis.ch
</source> 
<big>'''dig'''</big> 
Подобно команде '''''nslookup''''', выполняет "поиск имени узла" в Интернете.
Сравните вывод команды '''''dig -x''''' с выводом команд '''''ipcalc -h''''' и '''''nslookup'''''.
<source lang="bash">
bash$ dig -x 81.9.6.2
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NXDOMAIN, id: 11649
;; flags: qr rd ra; QUERY: 1, ANSWER: 0, AUTHORITY: 1, ADDITIONAL: 0
;; QUESTION SECTION:
;2.6.9.81.in-addr.arpa. IN PTR

;; AUTHORITY SECTION:
6.9.81.in-addr.arpa. 3600 IN SOA ns.eltel.net. noc.eltel.net.
2002031705 900 600 86400 3600

;; Query time: 537 msec
;; SERVER: 135.116.137.2#53(135.116.137.2)
;; WHEN: Wed Jun 26 08:35:24 2002
;; MSG SIZE rcvd: 91
</source> 
<big>'''traceroute'''</big> 
Утилита предназначена для исследования топологии сети посредством передачи ICMP пакетов удалённому узлу. Эта программа может работать в LAN, WAN и в Интернет. Удаленный узел может быть указан как по имени, так и по IP адресу. Вывод команды '''''traceroute''''' может быть передан по конвейеру утилитам [[grep]] или [[sed]], для дальнейшего анализа.
<source lang="bash">
bash$ traceroute 81.9.6.2
traceroute to 81.9.6.2 (81.9.6.2), 30 hops max, 38 byte packets
1 tc43.xjbnnbrb.com (136.30.178.8) 191.303 ms 179.400 ms 179.767 ms
2 or0.xjbnnbrb.com (136.30.178.1) 179.536 ms 179.534 ms 169.685 ms
3 192.168.11.101 (192.168.11.101) 189.471 ms 189.556 ms *
...
</source> 
<big>'''ping'''</big> 
Выполняет передачу пакета "ICMP ECHO_REQUEST" другой системе в сети. Чаще всего служит в качестве инструмента диагностики соединений, должна использоваться с большой осторожностью.
В случае успеха, '''''ping''''' возвращает код завершения 0, поэтому команда '''''ping''''' может использоваться в условных операторах.
<source lang="bash">
bash$ ping localhost
PING localhost.localdomain (127.0.0.1) from 127.0.0.1 : 56(84) bytes of data.
Warning: time of day goes back, taking countermeasures.
64 bytes from localhost.localdomain (127.0.0.1): icmp_seq=0 ttl=255 time=709 usec
64 bytes from localhost.localdomain (127.0.0.1): icmp_seq=1 ttl=255 time=286 usec
--- localhost.localdomain ping statistics ---
2 packets transmitted, 2 packets received, 0% packet loss
round-trip min/avg/max/mdev = 0.286/0.497/0.709/0.212 ms
</source> 
<big>'''whois'''</big> 
Выполняет поиск в DNS (Domain Name System). Ключом ''-h'' можно указать какой из ''whois'' серверов будет запрошен. 
<big>'''finger'''</big> 
Возвращает информацию о пользователях в сети. По желанию, эта команда может выводить содержимое файлов ''~/.plan'', ''~/.project'' и ''~/.forward'', указанного пользователя.
<source lang="bash">
bash$ finger
Login Name Tty Idle Login Time Office Office Phone
bozo Bozo Bozeman tty1 8 Jun 25 16:59
bozo Bozo Bozeman ttyp0 Jun 25 16:59
bozo Bozo Bozeman ttyp1 Jun 25 17:07

bash$ finger bozo
Login: bozo Name: Bozo Bozeman
Directory: /home/bozo Shell: /bin/bash
Office: 2355 Clown St., 543-1234
On since Fri Aug 31 20:13 (MST) on tty1 1 hour 38 minutes idle
On since Fri Aug 31 20:13 (MST) on pts/0 12 seconds idle
On since Fri Aug 31 20:13 (MST) on pts/1
On since Fri Aug 31 20:31 (MST) on pts/2 1 hour 16 minutes idle
No mail.
No Plan.
</source> 
По соображениям безопасности, в большинстве сетей служба '''''finger''''', и соответствующий демон,отключена. 
<big>'''chfn'''</big> 
Изменяет некоторые сведения о пользователе, такие как: полное имя, номер кабинета, телефон рабочий и домашний. Которые обычно выводятся командой '''''finger'''''. 
<big>'''vrfy'''</big> 
Проверка адреса электронной почты. 
'''Доступ к удалённым системам''' 
<big>'''sx,rx'''</big> 
Команды '''''sx''''' и '''''rx''''' служат для приёма/передачи файлов на/из удалённый узел в сети, по протоколу ''xmodem''. Входят в состав пакета ''minicom''. 
<big>'''sz,rz'''</big> 
Команды '''''sz''''' и '''''rz''''' служат для приёма/передачи файлов на/из удаленный узел в сети, по протоколу ''zmodem''. Протокол ''zmodem'' имеет некоторые преимущества перед протоколом ''xmodem'', в качестве такого преимущества можно назвать более высокую скорость передачи и возможность возобновления передачи, в случае её разрыва. Входят в состав пакета ''minicom''. 
<big>'''ftp'''</big> 
Под этим именем подразумевается утилита и протокол передачи файлов. Сеансы '''''ftp''''' могут устанавливаться из сценариев. 
<big>'''uucp'''</big> 
''Unix to Unix copy''. Это коммуникационный пакет для передачи файлов между Unix серверами. Сценарий на языке командной оболочки — один из самых эффективных способов автоматизации такого обмена. Похоже, что с появлением Интернет и электронной почты, '''''uucp''''' постепенно уходит в небытие, однако, она с успехом может использоваться в изолированных, не имеющих выхода в Интернет, сетях. 
<big>'''cu'''</big> 
''Call Up'' — выполняет соединение с удалённой системой, как простой терминал. Эта команда является частью пакета '''''uucp''''' и, своего рода, упрощенным вариантом команды '''''telnet'''''. 
<big>'''telnet'''</big> 
Утилита и протокол для подключения к удалённой системе. Протокол '''''telnet''''' небезопасен по своей природе, поэтому следует воздерживаться от его использования. 
<big>'''wget'''</big> 
[[wget]] — неинтерактивная утилита для скачивания файлов с Web или ftp сайтов.
<source lang="bash">
wget -p http://www.xyz23.com/file01.html
wget -r ftp://ftp.xyz24.net/~bozo/project_files/ -o $SAVEFILE
</source> 
<big>'''lynx'''</big> 
'''''lynx''''' — Web-браузер, внутри сценариев (с ключом ''-dump'') может использоваться для скачивания файлов с Web или ftp сайтов, в неинтерактивном режиме.
<source lang="bash">
lynx -dump http://www.xyz23.com/file01.html >$SAVEFILE
</source> 
<big>'''rlogin'''</big> 
''Remote login'' — инициирует сессию с удалённой системой. Эта команда небезопасна, вместо неё лучше использовать '''''ssh'''''. 
<big>'''rsh'''</big> 
''Remote shell'' — исполняет команду на удалённой системе. Эта команда небезопасна, вместо неё лучше использовать '''''ssh'''''. 
<big>'''rcp'''</big> 
''Remote copy'' — копирование файлов между двумя машинами через сеть. Подобно прочим r*утилитам, команда '''''rcp''''' небезопасна и потому, использовать её в сценариях нежелательно. В качестве замены можно порекомендовать '''''ssh''''' или '''''expect'''''. 
<big>'''ssh'''</big> 
''Secure shell'' — устанавливает сеанс связи и выполняет команды на удалённой системе. Выступает в качестве защищённой замены для '''''telnet''''', '''''rlogin''''', '''''rcp''''' и '''''rsh'''''. Использует идентификацию, аутентификацию и шифрование информации, передаваемой через сеть. Подробности вы найдете в ''man ssh''. 
'''Локальная сеть''' 
<big>'''write'''</big> 
Эта утилита позволяет передать текст сообщения на другой терминал (console или xterm). Разрешить или запретить доступ к терминалу можно с помощью команды '''''mesg'''''.
Поскольку команда '''''write''''' работает в интерактивном режиме, то, как правило, она не употребляется в сценариях. 
'''MAIL''' 
<big>'''mail'''</big> 
Чтение или передача электронной почты. Этот почтовый клиент командной строки с успехом может использоваться в сценариях.
 '''Пример''': '''''Сценарий, отправляющий себя самого по электронной почте.'''''
<source lang="bash">
#!/bin/bash
# self-mailer.sh: Сценарий отправляет себя самого по электронной почте
adr=${1:-`whoami`} # Если пользователь не указан, то — себе самому.
# Вызов 'self-mailer.sh wiseguy@superdupergenius.com'
# приведёт к передаче электронного письма по указанному адресу.
# Вызов 'self-mailer.sh' (без аргументов) — отправит письмо
# пользователю, запустившему сценарий, например, bozo@localhost.localdomain.
#
# Дополнительно о конструкции ${parameter:-default},
# см. раздел "Подстановка параметров"
# в главе "К вопросу о переменных".
# ============================================================================
cat $0 | mail -s "Сценарий \"`basename $0`\" отправил себя сам." "$adr"
# ============================================================================
# --------------------------------------------
# Поздравляю!
# Этот сценарий запустила какая-то "редиска",
# и заставила отправить этот текст к Вам.
# Очевидно кто-то не знает куда девать свое время.
# --------------------------------------------
echo "`date`, сценарий \"`basename $0`\" отправлен "$adr"."
exit 0
</source> 
<big>'''mailto'''</big> 
Команда '''''mailto''''', похожа на '''''mail''''', она также отправляет сообщения по электронной почте. Однако, кроме этого, '''''mailto''''' позволяет отправлять MIME (multimedia) сообщения. 
<big>'''vacation'''</big> 
Эта утилита предназначена для автоматической передачи ответов на электронные письма, например для того, чтобы уведомить отправителя о том, что получатель временно отсутствует. Работает совместно с '''''sendmail''''' и не может использоваться для передачи сообщений через коммутируемые линии (по модему).

=== Команды управления терминалом ===
'''Команды, имеющие отношение к консоли или терминалу''' 
<big>'''tput'''</big> 
Инициализация терминала или выполнение запроса к базе данных терминалов '''''terminfo'''''. С помощью '''''tput''''' можно выполнять различные операции. '''''tput clear''''' — эквивалентно команде '''''clear'''''. '''''tput reset''''' — эквивалентно команде '''''reset'''''. '''''tput sgr0''''' — так же сбрасывает настройки терминал, но без очистки экрана.
<source lang="bash">
bash$ tput longname
xterm terminal emulator (XFree86 4.0 Window System)
</source> 
Команда '''''tput cup X Y''''' перемещает курсор в координаты (X,Y). Обычно этой команде предшествует '''''clear''''', очищающая экран. 
Обратите внимание: '''''stty''''' предлагает более широкий диапазон возможностей. 
<big>'''infocmp'''</big> 
Cравнение или печать информации о характеристиках терминалов, хранящейся в базе данных '''''terminfo'''''.
<source lang="bash">
bash$ infocmp
# Reconstructed via infocmp from file:
/usr/share/terminfo/r/rxvt
rxvt|rxvt terminal emulator (X Window System),
am, bce, eo, km, mir, msgr, xenl, xon,
colors#8, cols#80, it#8, lines#24, pairs#64,
acsc=``aaffggjjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~,
bel=^G, blink=\E[5m, bold=\E[1m,
civis=\E[?25l,
clear=\E[H\E[2J, cnorm=\E[?25h, cr=^M,
...
</source> 
<big>'''reset'''</big> 
Сбрасывает настройки терминала и очищает экран. Как и в случае команды '''''clear''''', курсор и приглашение к вводу (''prompt'') выводятся в верхнем левом углу терминала. 
<big>'''clear'''</big> 
Команда '''''clear''''' просто очищает экран терминала или окно ''xterm''. Курсор и приглашение к вводу (''prompt'') выводятся в верхнем левом углу терминала. Эта команда может запускаться как из командной строки, так и из сценария. 
<big>'''script'''</big> 
Эта утилита позволяет сохранять в файле все символы, введённые пользователем c клавиатуры(вывод тоже). Получая, фактически, подробнейший синхронный протокол сессии. 

=== Команды выполнения математических операций ===
<big>'''factor'''</big> 
Разложение целого числа на простые множители.
<source lang="bash">
bash$ factor 27417
27417: 3 13 19 37
</source> 
<big>'''bc'''</big> 
Bash не в состоянии выполнять действия над числами с плавающей запятой и не содержит многих важных математических функций. К счастью существует '''''bc'''''.
Универсальная, выполняющая вычисления с произвольной точностью, утилита '''''bc''''' обладает некоторыми возможностями, характерными для языков программирования.
Синтаксис '''''bc''''' немного напоминает язык ''C''. Поскольку это утилита Unix, то она может достаточно широко использоваться в сценариях на языке командной оболочки, в том числе и в конвейерной обработке данных. Ниже приводится простой шаблон работы с утилитой '''''bc''''' в сценарии. Здесь используется приём подстановки команд. 
<source lang="bash">
variable=$(echo "OPTIONS; OPERATIONS" | bc)
</source> 
 '''Пример''': '''''Ежемесячные выплаты по займу.'''''
<source lang="bash">
#!/bin/bash
# monthlypmt.sh: Расчёт ежемесячных выплат по займу.
# Это измененный вариант пакета "mcalc" (mortgage calculator),
# написанного Jeff Schmidt и Mendel Cooper (ваш покорный слуга).
# http://www.ibiblio.org/pub/Linux/apps/financial/mcalc-1.6.tar.gz
echo
echo "Введите сумму займа, процентную ставку и срок займа,"
echo "для расчета суммы ежемесячных выплат."
bottom=1.0
echo
echo -n "Сумма займа (без запятых — с точностью до доллара) "
read principal
echo -n "Процентная ставка (процент) " # Если 12%, то нужно вводить "12", а не ".12".
read interest_r
echo -n "Срок займа (месяцев) "
read term
interest_r=$(echo "scale=9; $interest_r/100.0" | bc) # Здесь "scale" — точность вычислений.
interest_rate=$(echo "scale=9; $interest_r/12 + 1.0" | bc)
top=$(echo "scale=9; $principal*$interest_rate^$term" | bc)
echo; echo "Прошу подождать. Вычисления потребуют некоторого времени."
let "months = $term - 1"
# ====================================================================
for ((x=$months; x > 0; x--))
do
bot=$(echo "scale=9; $interest_rate^$x" | bc)
bottom=$(echo "scale=9; $bottom+$bot" | bc)
# bottom = $(($bottom + $bot"))
done
# --------------------------------------------------------------------
# Rick Boivie предложил более эффективную реализацию
# цикла вычислений, который дает выигрыш по времени на 2/3.
# for ((x=1; x <= $months; x++))
# do
# bottom=$(echo "scale=9; $bottom * $interest_rate + 1" | bc)
# done
# А затем нашёл ещё более эффективную альтернативу,
# которая выполняется в 20 раз быстрее !!!
# bottom=`{
# echo "scale=9; bottom=$bottom; interest_rate=$interest_rate"
# for ((x=1; x <= $months; x++))
# do
# echo 'bottom = bottom * interest_rate + 1'
# done
# echo 'bottom'
# } | bc` # Внедрить цикл 'for' в конструкцию подстановки команд.
# ====================================================================
# let "payment = $top/$bottom"
payment=$(echo "scale=2; $top/$bottom" | bc)
# Два знака после запятой, чтобы показать доллары и центы.

echo
echo "ежемесячные выплаты = \$$payment" # Вывести знак "доллара" перед числом.
echo

exit 0
# Упражнения:
# 1) Добавьте возможность ввода суммы с точностью до цента.
# 2) Добавьте возможность ввода процентной ставки как в виде процентов, так и в виде десятичного числа — доли целого.
# 3) Если вы действительно честолюбивы, добавьте в сценарий вывод полной таблицы помесячных выплат.
</source> 
 '''Пример''': '''''Перевод чисел из одной системы счисления в другую.'''''
<source lang="bash">
##########################################################################
# Shellscript: base.sh - вывод чисел в разных системах счисления (Bourne Shell)
# Author : Heiner Steven (heiner.steven@odn.de)
# Date : 07-03-95
# Category : Desktop
# $Id: base.sh,v 1.2 2000/02/06 19:55:35 heiner Exp $
##########################################################################
# Description
#
# Changes
# 21-03-95 stv исправлена ошибка, возникающая при вводе числа 0xb (0.2)
##########################################################################
# ==> Используется в данном документе с разрешения автора.
# ==> Комментарии добавлены автором документа.
NOARGS=65
PN=`basename "$0"` # Имя программы
VER=`echo '$Revision: 1.2 $' | cut -d' ' -f2` # ==> VER=1.2
Usage () {
echo "$PN - вывод чисел в различных системах счисления, $VER (stv '95)
Порядок использования: $PN [number ...]
Если число не задано, то производится ввод со stdin.
Число может быть:
двоичное — должно начинаться с комбинации символов 0b (например 0b1100)
восьмеричное — должно начинаться с 0 (например 014)
шестнадцатиричное — должно начинаться с комбинации символов 0x (например 0xc)
десятичное — в любом другом случае (например 12)" >&2
exit $NOARGS
} # ==> Функция вывода сообщения о порядке использования.
Msg () {
for i # ==> [список] параметров опущен.
do
echo "$PN: $i" >&2
done
}
Fatal () { Msg "$@"; exit 66; }
PrintBases () {
# Определение системы счисления
for i # ==> [список] параметров опущен...
do # ==> поэтому работает с аргументами командной строки.
case "$i" in
0b*) ibase=2;; # двоичная
0x*|[a-f]*|[A-F]*) ibase=16;; # шестнадцатиричная
0*) ibase=8;; # восьмеричная
[1-9]*) ibase=10;; # десятичная
*)
Msg "Ошибка в числе $i - число проигнорировано"
continue;;
esac
# Удалить префикс и преобразовать шестнадцатиричные цифры в верхний регистр (этого требует bc)
number=`echo "$i" | sed -e 's:^0[bBxX]::' | tr '[a-f]' '[A-F]'`
# ==> вместо "/", здесь используется символ ":" как разделитель для sed.
# Преобразование в десятичную систему счисления
dec=`echo "ibase=$ibase; $number" | bc` # ==> 'bc' используется как калькулятор.
case "$dec" in
[0-9]*) ;; # всё в порядке
*) continue;; # ошибка: игнорировать
esac
# Напечатать все преобразования в одну строку.
# ==> 'вложенный документ' — список команд для 'bc'.
echo `bc <<!
obase=16; "hex="; $dec
obase=10; "dec="; $dec
obase=8; "oct="; $dec
obase=2; "bin="; $dec
!
` | sed -e 's: : :g'
done
}
while [ $# -gt 0 ]
do
case "$1" in
--) shift; break;;
-h) Usage;; # ==> Вывод справочного сообщения.
-*) Usage;;
*) break;; # первое число
esac # ==> Хорошо бы расширить анализ вводимых символов.
shift
done
if [ $# -gt 0 ]
then
PrintBases "$@"
else # чтение со stdin
while read line
do
PrintBases $line
done
fi
</source> 
Один из вариантов вызова bc — использование вложенного документа, внедряемого в блок с подстановкой команд. Это особенно актуально, когда сценарий должен передать '''''bc''''' значительный по объему список команд и аргументов.
<source lang="bash">
variable=`bc << LIMIT_STRING
options
statements
operations
LIMIT_STRING`
</source>
...или...
<source lang="bash">
variable=$(bc << LIMIT_STRING
options
statements
operations
LIMIT_STRING)
</source> 
 '''Пример''': '''''Пример взаимодействия bc со "встроенным документом".'''''
<source lang="bash">
#!/bin/bash
# Комбинирование 'bc' с
# 'вложенным документом'.
var1=`bc << EOF
18.33 * 19.78
EOF`

echo $var1 # 362.56
# запись $( ... ) тоже работает.
v1=23.53
v2=17.881
v3=83.501
v4=171.63

var2=$(bc << EOF
scale = 4
a = ( $v1 + $v2 )
b = ( $v3 * $v4 )
a * b + 15.35
EOF
)
echo $var2 # 593487.8452
var3=$(bc -l << EOF
scale = 9
s ( 1.7 )
EOF
)
# Возвращается значение синуса от 1.7 радиана.
# Ключом "-l" вызывается математическая библиотека 'bc'.
echo $var3 # .991664810
# Попробуем функции...
hyp= # Объявление глобальной переменной.
hypotenuse () # Расчёт гипотенузы прямоугольного треугольника.
{
hyp=$(bc -l << EOF
scale = 9
sqrt ( $1 * $1 + $2 * $2 )
EOF
)
# К сожалению, функции Bash не могут возвращать числа с плавающей запятой.
}
hypotenuse 3.68 7.31
echo "гипотенуза = $hyp" # 8.184039344
exit 0
</source> 
 '''Пример''': '''''Вычисление числа "пи".'''''
<source lang="bash">
#!/bin/bash
# cannon.sh: Аппроксимация числа "пи".
# Это очень простой вариант реализации метода "Monte Carlo",
# математическое моделирование событий реальной жизни,
# для эмуляции случайного события используются псевдослучайные числа.

# Допустим, что мы располагаем картой квадратного участка поверхности со стороной квадрата 10000 единиц.
# На этом участке, в центре, находится совершенно круглое озеро, с диаметром в 10000 единиц.
# Т.е. озеро покрывает почти всю карту, кроме её углов.
# (Фактически — это квадрат со вписанным кругом.)
#
# Пусть по этому участку ведется стрельба железными ядрами из древней пушки
# Все ядра падают где-то в пределах данного участка, т.е. либо в озеро, либо на сушу, по углам участка.
# Поскольку озеро покрывает большую часть участка, то большинство ядер будет падать в воду.
# Незначительная часть ядер будет падать на твердую почву.
#
# Если произвести достаточно большое число неприцельных выстрелов по данному участку,
# то отношение попаданий в воду к общему числу выстрелов будет примерно равно#+ значению PI/4.
#
# По той простой причине, что стрельба фактически ведётся только по правому верхнему квадранту карты.
# (Предыдущее описание было несколько упрощено.)
#
# Теоретически, чем больше будет произведено выстрелов, тем точнее будет результат.
# Однако, сценарий на языке командной оболочки, в отличие от других языков программирования,
# в которых доступны операции с плавающей запятой, имеет некоторые ограничения.
# К сожалению, это делает вычисления менее точными.

DIMENSION=10000 # Длина стороны квадратного участка поверхности.
# Он же — верхний предел для генератора случайных чисел.
MAXSHOTS=1000 # Количество выстрелов.
# 10000 выстрелов (или больше) даст лучший результат, но потребует значительного количества времени.
PMULTIPLIER=4.0 # Масштабирующий коэффициент.

get_random ()
{
SEED=$(head -1 /dev/urandom | od -N 1 | awk '{ print $2 }')
RANDOM=$SEED # Из примера "seeding-random.sh"
let "rnum = $RANDOM % $DIMENSION" # Число не более чем 10000.
echo $rnum
}
distance= # Объявление глобальной переменной.
hypotenuse () # Расчет гипотенузы прямоугольного треугольника.
{ # Из примера "alt-bc.sh".
distance=$(bc -l << EOF
scale = 0
sqrt ( $1 * $1 + $2 * $2 )
EOF
)
# Установка "scale" в ноль приводит к округлению результата "вниз",
# это и есть то самое ограничение, накладываемое командной оболочкой.
# Что, к сожалению, снижает точность аппроксимации.
}

# main() {
# Инициализация переменных.
shots=0
splashes=0
thuds=0
Pi=0
while [ "$shots" -lt "$MAXSHOTS" ] # Главный цикл.
do
xCoord=$(get_random) # Получить случайные координаты X и Y.
yCoord=$(get_random)
hypotenuse $xCoord $yCoord # Гипотенуза = расстоянию.
((shots++))

printf "#%4d " $shots
printf "Xc = %4d " $xCoord
printf "Yc = %4d " $yCoord
printf "Distance = %5d " $distance # Расстояние от центра озера, с координатами (0,0).

if [ "$distance" -le "$DIMENSION" ]
then
echo -n "ШЛЁП! " # попадание в озеро
((splashes++))
else
echo -n "БУХ! " # попадание на твердую почву
((thuds++))
fi
Pi=$(echo "scale=9; $PMULTIPLIER*$splashes/$shots" | bc)
# Умножение на коэффициент 4.0.
echo -n "PI ~ $Pi"
echo
done
echo
echo "После $shots выстрела, примерное значение числа \"пи\" равно $Pi."
# Имеет тенденцию к завышению...
# Вероятно из-за ошибок округления и несовершенства генератора случайных чисел.
echo
#
}
exit 0
# Самое время задуматься над тем, является ли сценарий удобным средством
# для выполнения большого количества столь сложных вычислений.
#
# Тем не менее, этот пример может расцениваться как
# 1) Доказательство возможностей языка командной оболочки.
# 2) Прототип для "обкатки" алгоритма перед тем как перенести
# его на высокоуровневые языки программирования компилирующего типа.
</source> 
<big>'''dc'''</big> 
Утилита '''''dc''''' (''desk calculator'') — это калькулятор, использующий "Обратную Польскую Нотацию", и ориентированный на работу со стеком. Многие стараются избегать использования '''''dc''''', из-за непривычной формы записи операндов и операций. Однако, '''''dc''''' имеет и своих сторонников.
 '''Пример''': '''''Преобразование чисел из десятичной в шестнадцатиричную систему счисления.'''''
<source lang="bash">
#!/bin/bash
# hexconvert.sh: Преобразование чисел из десятичной в шестнадцатиричную систему счисления.
BASE=16 # Шестнадцатиричная.
if [ -z "$1" ]
then
echo "Порядок использования: $0 number"
exit $E_NOARGS
# Необходим аргумент командной строки.
fi
# Упражнение: добавьте проверку корректности аргумента.
hexcvt ()
{
if [ -z "$1" ]
then
echo 0
return # "Return" 0, если функции не был передан аргумент.
fi
echo ""$1" "$BASE" o p" | dc
# "o" устанавливает основание системы счисления для вывода.
# "p" выводит число, находящееся на вершине стека.
# См. 'man dc'.
return
}
hexcvt "$1"
exit 0
</source> 
Изучение страниц ''info dc'' позволит детальнее разобраться с утилитой. Однако, отряд "гуру", которые могут похвастать своим знанием этой мощной, но весьма запутанной утилиты, весьма немногочислен. 
 '''Пример''': '''''Разложение числа на простые множители.'''''
<source lang="bash">
#!/bin/bash
# factr.sh: Разложение числа на простые множители
MIN=2 # Не работает с числами меньше 2.
E_NOARGS=65
E_TOOSMALL=66

if [ -z $1 ]
then
echo "Порядок использования: $0 number"
exit $E_NOARGS
fi
if [ "$1" -lt "$MIN" ]
then
echo "Исходное число должно быть больше или равно $MIN."
exit $E_TOOSMALL
fi
# Упражнение: Добавьте проверку типа числа (не целые числа должны отвергаться).
echo "Простые множители для числа $1:"
# ---------------------------------------------------------------------------------
echo "$1[p]s2[lip/dli%0=1dvsr]s12sid2%0=13sidvsr[dli%0=1lrli2+dsi!>.]ds.xd1<2" | dc
# ---------------------------------------------------------------------------------
# Автор вышеприведенной строки: Michel Charpentier <charpov@cs.unh.edu>.
# Используется с его разрешения (спасибо).
exit 0
</source> 
<big>'''awk'''</big> 
Ещё один способ выполнения математических операций, над числами с плавающей запятой, состоит в создании сценария-обёртки, использующего математические функции [[awk]].
 '''Пример''': '''''Расчёт гипотенузы прямоугольного треугольника.'''''
<source lang="bash">
#!/bin/bash
# hypotenuse.sh: Возвращает "гипотенузу" прямоугольного треугольника.
# ( корень квадратный от суммы квадратов катетов)

ARGS=2 # В сценарий необходимо передать два катета.
E_BADARGS=65 # Ошибка в аргументах.
if [ $# -ne "$ARGS" ] # Проверка количества аргументов.
then
echo -e "\e[32mПорядок использования\e[0m: \e[31m`basename $0`\e[0m \e[34mкатет_1\e[0m \e[33mкатет_2\e[0m"
exit $E_BADARGS
fi
AWKSCRIPT=' { printf( "%3.7f\n", sqrt($1*$1 + $2*$2) ) } '
# команды и параметры, передаваемые в awk
echo -n "Гипотенуза прямоугольного треугольника, с катетами $1 и $2 = "
echo $1 $2 | awk "$AWKSCRIPT"
exit 0
</source> 

=== Прочие команды ===
'''Команды, которые нельзя отнести ни к одной из вышеперечисленных категорий''' 
<big>'''jot,seq'''</big> 
Эти утилиты выводят последовательность целых чисел с шагом, заданным пользователем.
По-умолчанию, выводимые числа отделяются друг от друга символом перевода строки, однако,с помощью ключа ''-s'' может быть задан другой разделитель.
<source lang="bash">
bash$ seq 5
1
2
3
4
5
bash$ seq -s : 5
1:2:3:4:5
</source> 
Обе утилиты, и '''''jot''''', и '''''seq''''', очень удобно использовать для генерации списка аргументов в цикле ''for''.
 '''Пример''': '''''Использование seq для генерации списка аргументов цикла for.'''''
<source lang="bash">
#!/bin/bash
# Утилита "seq"
echo
for a in `seq 80` # или так: for a in $( seq 80 )
# То же самое, что и for a in 1 2 3 4 5 ... 80 (но как экономит время и силы!).
# Можно использовать и 'jot' (если эта утилита имеется в системе).
do
echo -n "$a "
done # 1 2 3 4 5 ... 80
# Пример использования вывода команды для генерации
# [списка] аргументов цикла "for".
echo; echo
COUNT=80 # Да, 'seq' допускает указание переменных в качестве параметра.
for a in `seq $COUNT` # или так: for a in $( seq $COUNT )
do
echo -n "$a "
done # 1 2 3 4 5 ... 80
echo; echo
BEGIN=75
END=80
for a in `seq $BEGIN $END`
# Если "seq" передаются два аргумента, то первый означает начальное число последовательности, второй — последнее,
do
echo -n "$a "
done # 75 76 77 78 79 80
echo; echo
BEGIN=45
INTERVAL=5
END=80
for a in `seq $BEGIN $INTERVAL $END`
# Если "seq" передаётся три аргумента, то первый аргумент — начальное число в последовательности,
# второй — шаг последовательности, и третий — последнее число в последовательности.
do
echo -n "$a "
done # 45 50 55 60 65 70 75 80
echo; echo
exit 0
</source> 
<big>'''getopt'''</big> 
Команда '''''getopt''''' служит для разбора командной строки, выделяя из неё ключи — символы, с предшествующим символом дефиса. В этой утилите имеется, встроенный в Bash, аналог — '''''getopts''''', более мощная и универсальная команда. Тем не менее, команда '''''getopt''''', с ключом ''-l'', позволяет производить разбор "длинных" ключей и допускает переупорядочивание ключей.
 '''Пример''': '''''Использование getopt для разбора аргументов командной строки.'''''
<source lang="bash">
#!/bin/bash
# ex33a.sh

# Попробуйте следующие варианты вызова этого сценария.
# sh ex33a -a
# sh ex33a -abc
# sh ex33a -a -b -c
# sh ex33a -d
# sh ex33a -dXYZ
# sh ex33a -d XYZ
# sh ex33a -abcd
# sh ex33a -abcdZ
# sh ex33a -z
# sh ex33a a
# Объясните полученные результаты.
E_OPTERR=65
if [ "$#" -eq 0 ]
then # Необходим по меньшей мере один аргумент.
echo "Порядок использования: $0 -[options a,b,c]"
exit $E_OPTERR
fi
set -- `getopt "abcd:" "$@"`
# Запись аргументов командной строки в позиционные параметры.
# Что произойдёт, если вместо "$@" указать "$*"?
while [ ! -z "$1" ]
do
case "$1" in
-a) echo "Опция \"a\"";;
-b) echo "Опция \"b\"";;
-c) echo "Опция \"c\"";;
-d) echo "Опция \"d\" $2";;
*) break;;
esac
shift
done
# Вместо 'getopt' лучше использовать встроенную команду 'getopts',
exit 0
</source> 
<big>'''run-parts'''</big> 
Команда run-parts запускает на исполнение все сценарии, в порядке возрастания имён файлов-сценариев, в заданном каталоге. Естественно, файлы сценариев должны иметь права на исполнение. Демон ''cron'' вызывает '''''run-parts''''' для запуска сценариев из каталогов ''/etc/cron.*''.
 
<big>'''yes'''</big> 
По-умолчанию, команда '''''yes''''' выводит на ''stdout'' непрерывную последовательность символов ''y'', разделённых символами перевода строки. Исполнение команды можно прервать комбинацией клавиш ''Ctrl-c''. Команду '''''yes''''' можно заставить выводить иную последовательность символов. Теперь самое время задаться вопросом о практической пользе этой команды. Основное применение этой команды состоит в том, что вывод от неё может быть передан, через конвейер, другой команде, ожидающей реакции пользователя. В результате получается, своего рода, слабенькая версия команды ''expect''. 
Запускает '''''fsck''''' в неинтерактивном режиме (<big>'''будьте осторожны!'''</big>): 
<source lang="bash">
yes | fsck /dev/hda1
</source>
Имеет тот же эффект, что и '''''rm -rf dirname''''' (<big>'''будьте осторожны!'''</big>): 
<source lang="bash">
yes | rm -r dirname
</source> 
<big>'''Внимание!'''</big>Передача вывода команды '''''yes''''' по конвейеру потенциально опасным командам, таким как '''''fsck''''' или '''''fdisk''''' может дать нежелательные побочные эффекты. 
<big>'''banner'''</big> 
Печатает на ''stdout'' заданную строку символов (не более 10), рисуя каждый символ строки при помощи символа '#'. Вывод от команды может быть перенаправлен на принтер.
 
<big>'''printenv'''</big> 
Выводит все переменные окружения текущего пользователя.
<source lang="bash">
bash$ printenv | grep HOME
HOME=/home/bozo
</source> 
<big>'''lp'''</big> 
Команды '''''lp''''' и '''''lpr''''' отправляют файлы в очередь печати для вывода на принтер. Названия этих команд произошли от ''"line printers"''.
<source lang="bash">
bash$ lp file1.txt или bash lp <file1.txt
</source> 
Очень часто используются в комбинации с командой форматированного вывода '''''pr'''''.
<source lang="bash">
bash$ pr -options file1.txt | lp
</source> 
Программы подготовки текста к печати, такие как '''''groff''''' и ''Ghostscript'', так же могут напрямую взаимодействовать с '''''lp'''''.
<source lang="bash">
bash$ groff -Tascii file.tr | lp
bash$ gs -options | lp file.ps
</source> 
Команда '''''lpq''''' предназначена для просмотра очереди заданий печати, а '''''lprm''''' — для удаления заданий из очереди. 
<big>'''tee'''</big> 
[Unix заимствовал эту идею из водопроводного дела.]
Это оператор перенаправления, но с некоторыми особенностями. Подобно водопроводным трубам, '''''tee''''' позволяет "направить поток" данных в несколько файлов и на ''stdout'' одновременно, никак не влияя на сами данные. Эта команда может оказаться очень полезной при отладке.
<source lang="bash">
tee |------> в файл
|
===============|===============
command--->----|-operator-->---> результат работы команд(ы)
==================
cat listfile* | sort | tee check.file | uniq > result.file
</source> 
(Здесь, в файл check.file будут записаны данные из всех "listfile*", в отсортированном виде до того, как повторяющиеся строки будут удалены командой '''''uniq'''''.) 
<big>'''mkfifo'''</big> 
Эта, редко встречающаяся, команда создаёт именованный канал — очередь, через который производится обмен данными между процессами. Как правило, один процесс записывает данные в очередь (FIFO), а другой читает данные из очереди. 
<big>'''pathchk'''</big> 
Производит проверку полного имени файла — проверяет, доступны ли на чтение, каталоги в пути к файлу, и не превышает ли длина полного имени файла 255 символов. При несоблюдении одного из условий — возвращает сообщение об ошибке. К сожалению, '''''pathchk''''' не возвращает соответствующего кода ошибки, и потому, в общем-то, бесполезна в сценариях. Вместо неё лучше использовать операторы проверки файлов. 
<big>'''dd'''</big> 
Эта немного непонятная и "страшная" команда ("data duplicator") изначально использовалась для переноса данных на магнитной ленте между микрокомпьютерами с ОС Unix и майнфреймами IBM. Команда [[dd]] просто создаёт копию файла (или ''stdin/stdout''), выполняя по пути некоторые преобразования. Один из вариантов: преобразование из ASCII в EBCDIC, '''''[[dd|dd --help]]''''' выведет список возможных вариантов преобразований и опций этой мощной утилиты. 
<source lang="bash">
# Изучаем 'dd'.
n=3
p=5
input_file=project.txt
output_file=log.txt
dd if=$input_file of=$output_file bs=1 skip=$((n-1)) count=$((p-n+1)) 2> /dev/null # Извлечёт из $input_file символы с n-го по p-й.
echo -n "hello world" | dd cbs=1 conv=unblock 2> /dev/null
# Выведет "hello world" вертикально.
# Спасибо, S.C.
</source> 
Для демонстрации возможностей [[dd]], попробуем перехватить нажатия на клавиши.
 '''Пример''': '''''Захват нажатых клавиш.'''''
<source lang="bash">
#!/bin/bash
# Захват нажатых клавиш.
keypresses=4 # Количество фиксируемых нажатий.
old_tty_setting=$(stty -g) # Сохранить настройки терминала.
echo "Нажмите $keypresses клавиши."
stty -icanon -echo # Запретить канонический режим.
# Запретить эхо-вывод.
keys=$(dd bs=1 count=$keypresses 2> /dev/null)
# 'dd' использует stdin, если "if" не задан.
stty "$old_tty_setting" # Восстановить настройки терминала.
echo "Вы нажали клавиши \"$keys\"."
# Спасибо S.C.
exit 0
</source> 
Команда [[dd]] имеет возможность произвольного доступа к данным в потоке.
<source lang="bash">
echo -n . | dd bs=1 seek=4 of=file conv=notrunc
# Здесь, опция "conv=notrunc" означает, что выходной файл не будет усечен.
# Спасибо, S.C.
</source> 
Команда [[dd]] может использоваться для создания образов дисков, считывая данные прямо с устройств, таких как дискеты, компакт-диски, магнитные ленты. Обычно она используется для создания загрузочных дискет.
<source lang="bash">
dd if=kernel-image of=/dev/fd0H1440
</source> 
Точно так же, [[dd]] может скопировать всё содержимое дискеты, даже с неизвестной файловой системой, на жёсткий диск в виде файла-образа.
<source lang="bash">
dd if=/dev/fd0 of=/home/bozo/projects/floppy.img
</source> 
Ещё одно применение [[dd]] — создание временного swap-файла и ram-дисков. Она может создавать даже образы целых разделов жёсткого диска, хотя и не рекомендуется делать это без особой на то необходимости. Многие (которые, вероятно, не знают чем себя занять) постоянно придумывают всё новые и новые области применения команды [[dd]]. 
 '''Пример''': '''''Надёжное удаление файла.'''''
<source lang="bash">
#!/bin/bash
# blotout.sh: Надежно удаляет файл.
# Этот сценарий записывает случайные данные в заданный файл, затем записывает туда нули и наконец удаляет файл.
# После такого удаления даже анализ дисковых секторов не даст ровным счётом ничего.
PASSES=7 # Количество проходов по файлу.
BLOCKSIZE=1 # операции ввода/вывода в/из /dev/urandom требуют указания размера блока, иначе вы не получите желаемого результата.
E_BADARGS=70
E_NOT_FOUND=71
E_CHANGED_MIND=72
if [ -z "$1" ] # Имя файла не указано.
then
echo "Порядок использования: `basename $0` filename"
exit $E_BADARGS
fi
file=$1
if [ ! -e "$file" ]
then
echo "Файл \"$file\" не найден."
exit $E_NOT_FOUND
fi
echo; echo -n "Вы совершенно уверены в том, что желаете уничтожить \"$file\" (y/n)? "
read answer
case "$answer" in
[nN]) echo "Передумали? Операция отменена."
exit $E_CHANGED_MIND
;;
*) echo "Уничтожается файл \"$file\".";;
esac
flength=$(ls -l "$file" | awk '{print $5}') # Поле с номером 5 — это длина файла.
pass_count=1
echo
while [ "$pass_count" -le "$PASSES" ]
do
echo "Проход #$pass_count"
sync # Вытолкнуть буферы.
dd if=/dev/urandom of=$file bs=$BLOCKSIZE count=$flength # Заполнить файл случайными данными.
sync # Снова вытолкнуть буферы.
dd if=/dev/zero of=$file bs=$BLOCKSIZE count=$flength # Заполнить файл нулями.
sync # Снова вытолкнуть буферы.
let "pass_count += 1"
echo
done
rm -f $file # Наконец удалить изрядно "подпорченный" файл.
sync # Вытолкнуть буферы в последний раз.
echo "Файл \"$file\" уничтожен."; echo

# Это довольно надёжный, хотя и достаточно медленный способ уничтожения файлов.
# Более эффективно это делает команда "shred", входящая в состав пакета GNU "fileutils".
# Уничтоженный таким образом файл, не сможет быть восстановлен обычными методами.
# Однако...
# эта метода вероятно НЕ сможет противостоять аналитическим службам из СООТВЕТСТВУЮЩИХ ОРГАНОВ.
# Tom Vier разработал пакет "wipe", который более надежно стирает файлы, чем этот простой сценарий.
# http://www.ibiblio.org/pub/Linux/utils/file/wipe-2.0.0.tar.bz2
# Для более глубоко изучения проблемы надёжного удаления файлов, рекомендую обратиться к cnfnmt Peter Gutmann,
# "Secure Deletion of Data From Magnetic and Solid-State Memory".
# http://www.cs.auckland.ac.nz/~pgut001/pubs/secure_del.html
exit 0
</source> 
<big>'''od'''</big> 
Команда '''''od''''' (''octal dump'') производит преобразование ввода (или файла) в один или несколько форматов, в соответствии с указанными опциями. При отсутствии опций используется восьмеричный формат (опция ''-o''). Эта команда полезна при просмотре или обработке файлов с двоичными данными, например ''/dev/urandom''. 
<big>'''hexdump'''</big> 
Выводит дамп двоичных данных из файла в восьмеричном, шестнадцатиричном, десятичном виде или в виде ASCII. Эту команду, с массой оговорок, можно назвать эквивалентом команды '''''od'''''. 
<big>'''objdump'''</big> 
Отображает сведения об исполняемом или объектном файле либо в шестнадцатиричной форме, либо в виде дизассемблерного листинга (с ключом ''-d'').
<source lang="bash">
bash$ objdump -d /bin/ls
/bin/ls: file format elf32-i386

Disassembly of section .init:
080490bc <.init>:
80490bc: 55 push %ebp
80490bd: 89 e5 mov %esp,%ebp
. . .
</source> 
<big>'''mcookie'''</big> 
Эта команда создает псевдослучайные шестнадцатиричные 128-битные числа, так называемые "magic cookie", обычно используется X-сервером в качестве "сигнатуры" авторизации. В сценариях может использоваться как малоэффективный генератор случайных чисел.
<source lang="bash">
random000=$(mcookie)
</source> 
Конечно, для тех же целей, сценарий может использовать ''md5''.
<source lang="bash">
# Сценарий вычисляет контрольную сумму для самого себя.
random001=`md5sum $0 | awk '{print $1}'`
# 'awk' удаляет имя файла.
</source> 
С помощью '''''mcookie''''' можно создавать "уникальные" имена файлов.
 '''Пример''': '''''Генератор имён файлов.'''''
<source lang="bash">
#!/bin/bash
# tempfile-name.sh: Генератор имен временных файлов
BASE_STR=`mcookie` # 32-символьный (128 бит) magic cookie.
POS=11 # Произвольная позиция в строке magic cookie.
LEN=5 # $LEN последовательных символов.
prefix=temp # В конце концов это временный ("temp") файл.
suffix=${BASE_STR:POS:LEN}
# Извлечь строку, длиной в 5 символов, начиная с позиции 11.
temp_filename=$prefix.$suffix
# Сборка имени файла.
echo "Имя временного файла = \"$temp_filename\""
# sh tempfile-name.sh
# Имя временного файла = temp.e19ea
exit 0
</source> 
<big>'''units'''</big> 
Эта утилита производит преобразование величин из одних единиц измерения в другие. Как правило вызывается в интерактивном режиме, ниже приводится пример использования '''''units''''' в сценарии.
 '''Пример''': '''''Преобразование метров в мили.'''''
<source lang="bash">
#!/bin/bash
# unit-conversion.sh
convert_units () # Принимает в качестве входных параметров единицы измерения.
{
cf=$(units "$1" "$2" | sed --silent -e '1p' | awk '{print $2}')
# Удаляет все кроме коэффициентов преобразования.
echo "$cf"
}
Unit1=miles
Unit2=meters
cfactor=`convert_units $Unit1 $Unit2`
quantity=3.73
result=$(echo $quantity*$cfactor | bc)
echo "В $quantity милях $result метров."
# Что произойдет, если в функцию передать несовместимые единицы измерения, например "acres" (акры) and "miles" (мили)?
exit 0
</source> 
<big>'''m4'''</big> 
Не команда, а клад, '''''m4''''' — это мощный фильтр обработки макроопределений, фактически — целый язык программирования. Изначально создававшаяся как препроцессор для RatFor, '''''m4''''' оказалась очень полезной и как самостоятельная утилита. Фактически, '''''m4''''' сочетает в себе функциональные возможности '''''eval''''', '''''tr''''', '''''awk''''', и дополнительно предоставляет обширные возможности по созданию новых макроопределений. В апрельском выпуске, за 2002 год, журнала ''Linux Journal'' вы найдёте замечательную статью, описывающую возможности утилиты '''''m4'''''.
 '''Пример''': '''''Работа с m4.'''''
<source lang="bash">
#!/bin/bash
# m4.sh: Демонстрация некоторых возможностей макропроцессора m4
# Строки
string=abcdA01
echo "len($string)" | m4 # 7
echo "substr($string,4)" | m4 # A01
echo "regexp($string,[0-1][0-1],\&Z)" | m4 # 01Z
# Арифметика
echo "incr(22)" | m4 # 23
echo "eval(99 / 3)" | m4 # 33
exit 0
</source> 
<big>'''doexec'''</big> 
Команда '''''doexec''''' предоставляет возможность передачи произвольного списка аргументов внешней программе. В частности, передавая ''argv[0]'' (для сценариев соответствует специальной переменной ''$0''), можно вызвать программу под другим именем, определяя тем самым, её реакцию. Например, пусть в каталоге ''/usr/local/bin'' имеется программа с именем "aaa", которая при вызове '''''doexec /usr/local/bin/aaa list''''' выведет список всех файлов в текущем каталоге, имена которых начинаются с символа "a", а при вызове той же самой программы как '''''doexec/usr/local/bin/aaa delete''''', она удалит эти файлы. Естественно, реакция программы на своё собственное имя должна быть реализована в коде программы, для сценария на языке командной оболочки это может выглядеть примерно так: 
<source lang="bash">
case `basename $0` in
"name1" ) реакция на вызов под именем name1;;
"name2" ) реакция на вызов под именем name2;;
"name3" ) реакция на вызов под именем name3;;
* ) действия по-умолчанию;;
esac
</source> 
<big>'''dialog'''</big> 
Утилита '''''dialog''''' предоставляет в распоряжение программиста целый набор инструментов для построения интерактивного интерфейса в сценариях. Более совершенные разновидности команды '''''dialog''''' — '''''gdialog''''', '''''Xdialog''''' и '''''kdialog''''' — которые используют в своей работе графические элементы управления X-Windows.

== Команды системного администрирования ==
Примеры использования большинства этих команд вы найдёте в сценариях начальной загрузки и остановки системы, в каталогах ''/etc/rc.d''. Они, обычно, вызываются пользователем ''root'' и используются для администрирования системы или восстановления файловой системы. Эти команды должны использоваться с большой осторожностью, так как некоторые из них могут разрушить систему, при неправильном использовании. 
'''Пользователи и группы''' 
<big>'''users'''</big> 
Выведет список всех зарегистрировавшихся пользователей. Она, до некоторой степени,является эквивалентом команды '''''who -q'''''. 
<big>'''groups'''</big> 
Выводит список групп, в состав которых входит текущий пользователь. Эта команда соответствует внутренней переменной '''$GROUPS''', но выводит названия групп, а не их числовые идентификаторы.
<source lang="bash">
bash$ groups
bozita cdrom cdwriter audio xgrpbash
$ echo $GROUPS
501
</source> 
<big>'''chown,chgrp'''</big> 
Команда [[Chown_—_Команда_назначения_владельца_файлов_и/или_каталога|chown]] изменяет владельца файла или файлов. Эта команда полезна в случаях, когда '''''root''''' хочет передать монопольное право на файл от одного пользователя другому. Обычный пользователь не в состоянии изменить владельца файла, за исключением своих собственных файлов.
<source lang="bash">root# chown bozo *.txt</source> 
Команда [[Chgrp_—_Команда_изменяющая_группу_владельца_файла|chgrp]] изменяет группу, которой принадлежит файл или файлы. Чтобы изменить группу, вы должны быть владельцем файла (при этом должны входить в состав указываемой группы) или ''привилегированным пользователем''(''root'').
<source lang="bash">
chgrp --recursive dunderheads *.data
# Группа "dunderheads" станет владельцем всех файлов "*.data"
# во всех подкаталогах текущей директории ($PWD) (благодаря ключу "--recursive").
</source> 
<big>'''useradd,userdel'''</big> 
Команда [[useradd]] добавляет учетную запись нового пользователя в систему и создаёт домашний каталог для данного пользователя. Противоположная, по смыслу, команда '''''userdel''''' удаляет учетную запись пользователя из системы, и, соответствующие файлы. Команда '''''adduser''''' является синонимом для [[useradd]] и, как правило, является обычной символической ссылкой на [[useradd]]. 
<big>'''usermod'''</big> 
Модификация (изменение) характеристик пользовательского аккаунта. Может изменить пароль пользователя, членство в группах срок действия аккаунта и другие характеристики. С помощью этой команды можно заблокировать пользовательский пароль, что равносильно блокировке аккаунта. 
<big>'''groupmod'''</big> 
Модификация (изменение) характеристик группы. С помощью этой команды можно изменить имя группы и/или ID группы.
<big>'''id'''</big> 
Команда id выводит идентификатор пользователя (реальный и эффективный) иидентификаторы групп, в состав которых входит пользователь. По сути — выводит содержимое переменных '''$UID''', '''$EUID''' и '''$GROUPS'''.
<source lang="bash">
bash$ id
uid=501(bozo) gid=501(bozo) groups=501(bozo),22(cdrom),80(cdwriter),81(audio)
bash$ echo $UID
501
</source> 
Команда '''''id''''' выводит эффективный идентификатор только тогда, когда он отличается от реального. 
<big>'''who'''</big> 
Выводит список пользователей, работающих в настоящий момент в системе.
<source lang="bash">
bash$ who
bozo tty1 Apr 27 17:45
bozo pts/0 Apr 27 17:46
bozo pts/1 Apr 27 17:47
bozo pts/2 Apr 27 17:49
</source> 
С ключом ''-m'' — выводит информацию только о текущем пользователе. Если число аргументов, передаваемых команде, равно двум, то это эквивалентно вызову '''''who -m''''', например ''who am i'' или ''who The Man''.
<source lang="bash">
bash$ who -m
localhost.localdomain!bozo pts/2 Apr 27 17:49
</source> 
'''''whoami''''' — похожа на '''''who -m''''', но выводит только имя пользователя.
<source lang="bash">
bash$ whoami
bozo
</source> 
<big>'''w'''</big> 
Выводит информацию о системе, список пользователей, подключенных к системе и процессы, связанные с пользователями. Это расширенная версия команды '''''who'''''. Вывод от команды '''''w''''' может быть передан по конвейеру команде [[grep]], с целью поиска требуемого пользователя и/или процесса.
<source lang="bash">
bash$ w | grep startx
bozo tty1 - 4:22pm 6:41 4.47s 0.45s startx
</source> 
<big>'''logname'''</big> 
Выводит имя текущего пользователя (из файла ''/var/run/utmp''). Это довольно близкий эквивалент команды '''''whoami'''''.
<source lang="bash">
bash$ logname
bozo
</source> 
Команда '''''logname''''' выводит имя пользователя, зарегистрировавшегося в системе(залогировавшегося), в то время как '''''whoami''''' — даёт имя пользователя, под которым исполняется текущий процесс. Как я уже упоминал — это не всегда одно и то же.
<source lang="bash">
bash$ whoami
bozo
</source> 
Однако... 
<source lang="bash">
bash$ su
Password: ......
bash# whoami
root
bash# logname
bozo
</source> 
<big>'''su'''</big> 
Команда предназначена для запуска программы или сценария от имени другого пользователя. '''''su rjones''''' — запускает командную оболочку от имени пользователя ''rjones''. Запуск команды '''''su''''' без параметров означает запуск командной оболочки от имени привилегированного пользователя ''root''. 
<big>'''sudo'''</big> 
Исполняет заданную команду от имени пользователя ''root'' (или другого пользователя).
<source lang="bash">
#!/bin/bash
# Доступ к "секретным" файлам.
sudo cp /root/secretfile /home/bozo/secret
</source> 
Имена пользователей, которым разрешено использовать команду '''''sudo''''', хранятся в файле ''/etc/sudoers''. 
<big>'''passwd'''</big> 
Устанавливает или изменяет пароль пользователя. Команда '''''passwd''''' может использоваться в сценариях, но это плохая практика.
 '''Пример''': '''''Установка нового пароля.'''''
<source lang="bash">
#!/bin/bash
# setnew-password.sh: Не очень хорошая идея.
# Этот сценарий должен запускаться с правами root, а ещё лучше — вообще не запускать его.
ROOT_UID=0 # Root имеет $UID равный 0.
E_WRONG_USER=65 # Не root?
E_NOSUCHUSER=70
SUCCESS=0
if [ "$UID" -ne "$ROOT_UID" ]
then
echo; echo "Только root может запускать этот сценарий."; echo
exit $E_WRONG_USER
else
echo; echo "Вам не следовало бы запускать этот сценарий."
fi
username=bozo
NEWPASSWORD=security_violation
# Проверить — есть ли такой пользователь.
cat /etc/passwd | grep -q "$username"
if [ $? -ne $SUCCESS ]
then
echo "Пользователь $username не найден."
echo "Пароль не был изменен."
exit $E_NOSUCHUSER
fi
echo "$NEWPASSWORD" | passwd --stdin "$username"
# Ключ '--stdin' указывает 'passwd'
# получить новый пароль с stdin (или из конвейера).
echo; echo "Пароль пользователя $username изменен!"
# Использование команды 'passwd' в сценариях крайне опасно.
exit 0
</source> 
Команда '''''passwd''''' с ключами ''-l'', ''-u'' и ''-d'' выполняет блокировку, разблокировку и удаление пароля пользователя. Только ''root'' может вызывать команду '''''passwd''''' с этими ключами. 
<big>'''ac'''</big> 
Выводит время работы пользователей, основываясь на записях в файле ''/var/log/wtmp''. Это одна из утилит пакета ''GNU acct''. 
<source lang="bash">
bash$ ac
total 68.08
</source> 
<big>'''last'''</big> 
Выводит информацию о последних входах/выходах пользователей в сиcтему, основываясь на записях в файле ''/var/log/wtmp''. Эта команда может отображать информацию об удаленных (в смысле — с удалённого терминала) соединениях. 
<big>'''newgrp'''</big> 
Позволяет сменить активную группу пользователя. Пользователь остается в системе и текущий каталог не изменяется, но права доступа к файлам вычисляются в соответствии с новыми реальным и эффективным идентификаторами группы. Эта команда используется довольно редко, так как пользователь, обычно, является членом нескольких групп. 
'''Терминалы''' 
<big>'''tty'''</big> 
Выводит имя терминала текущего пользователя. Обратите внимание: каждое отдельное окно xterm считается отдельным терминалом.
<source lang="bash">
bash$ tty
/dev/pts/1
</source> 
<big>'''stty'''</big> 
Выводит и/или изменяет настройки терминала. Эта сложная команда используется в сценариях для управления поведением терминала.
 '''Пример''': '''''Установка символа "забоя".'''''
<source lang="bash">
#!/bin/bash
# erase.sh: Использование команды "stty" для смены клавиши "забоя" при чтении ввода.
echo -n "Как Вас зовут? "
read name # Попробуйте стереть последние символы при вводе.
# Всё работает.
echo "Вас зовут $name."
stty erase '#' # Теперь, чтобы стереть символ нужно использовать клавишу
"#".
echo -n "Как Вас зовут? "
read name # Попробуйте стереть последние символы при вводе с помощью
"#".
echo "Вас зовут $name."
exit 0
</source> 
 '''Пример''': '''''Невидимый пароль: Отключение эхо-вывода на терминал.'''''
<source lang="bash">
#!/bin/bash
echo
echo -n "Введите пароль "
read passwd
echo "Вы ввели пароль: $passwd"
echo -n "Если кто-нибудь в это время заглядывал Вам через плечо, "
echo "то теперь он знает Ваш пароль."
echo && echo # Две пустых строки через "and list".
stty -echo # Отключить эхо-вывод.
echo -n "Введите пароль еще раз "
read passwd
echo
echo "Вы ввели пароль: $passwd"
echo
stty echo # Восстановить эхо-вывод.
exit 0
</source> 
 '''Пример''': '''''Перехват нажатия на клавиши с помощью stty.'''''
<source lang="bash">
#!/bin/bash
# keypress.sh: Определение нажатых клавиш.
echo
old_tty_settings=$(stty -g) # Сохранить прежние настройки.
stty -icanon
Keypress=$(head -c1) # или $(dd bs=1 count=1 2> /dev/null)
# для других, не GNU, систем
echo
echo "Была нажата клавиша \""$Keypress"\"."
echo
stty "$old_tty_settings" # Восстановить прежние настройки.
# Спасибо, Stephane Chazelas(S.C.).
exit 0
</source> 
{| class="wikitable"
|-
! Терминалы и их режимы работы
|-
| Как правило, терминалы работают в каноническом режиме. Когда пользователь нажимает какую-либо клавишу, то соответствующий ей символ не сразу передаётся программе, исполняемой в окне терминала. Этот символ поступает сначала в локальный буфер терминала. Когда пользователь нажимает клавишу ''ENTER'', то тогда всё содержимое буфера передаётся программе. 
<source lang="bash">
bash$ stty -a
speed 9600 baud; rows 36; columns 96; line = 0;
intr = ^C; quit = ^\; erase = ^H; kill = ^U; eof = ^D; eol = <undef>; eol2 = <undef>;
start = ^Q; stop = ^S; susp = ^Z; rprnt = ^R; werase = ^W; lnext = ^V; flush = ^O;
...
isig icanon iexten echo echoe echok -echonl -noflsh -xcase -tostop -echoprt
</source> 
В каноническом режиме можно использовать символы редактирования во время ввода. 
<source lang="bash">
bash$ cat > filexxx
wha<ctl-W>I<ctl-H>foo bar<ctl-U>hello world<ENTER>
<ctl-D>
bash$ cat filexxx
hello world
bash$ bash$ wc -c < file13
</source> 
Процесс в терминале получит только 13 символов (12 алфавитных символов и символ перевода строки), хотя пользователь нажал 26 клавиш. 
В неканоническом ("сыром") режиме, каждая нажатая клавиша (включая специальные символы редактирования, такие как ''Ctl-H'') сразу же передается исполняющемуся в терминале процессу.
Под управлением Bash, базовый терминальный редактор заменяется более сложным терминальным редактором Bash. Например, если вы нажмете комбинацию клавиш ''Ctl-A'' в командной строке Bash, то вы не увидите символов ''^A'', которые выводит терминал, вместо этого Bash получит символ ''\1'', проанализирует его и переместит курсор в начало строки. ©''Stephane Chazelas''
|} 
<big>'''tset'''</big> 
Выводит или изменяет настройки терминала. Это более слабая версия '''''stty'''''.
<source lang="bash">
bash$ tset -r
Terminal type is xterm-xfree86.
Kill is control-U (^U).
Interrupt is control-C (^C).
</source> 
<big>'''setserial'''</big> 
Настройка параметров последовательного порта. Эта команда должна запускаться пользователем, обладающим привилегиями ''root''. Эту команду можно встретить в сценариях настройки системы. 
<source lang="bash">
# Взято из /etc/pcmcia/serial :
IRQ=`setserial /dev/$DEVICE | sed -e 's/.*IRQ: //'`
setserial /dev/$DEVICE irq 0 ; setserial /dev/$DEVICE irq $IRQ
</source> 
<big>'''getty,agetty'''</big> 
Программа '''''getty''''' или '''''agetty''''' запускается процессом ''init'' и обслуживает процедуру входа пользователя в систему. Эти команды не используются в сценариях. 
<big>'''mesg'''</big> 
Разрешает или запрещает доступ к терминалу текущего пользователя командой '''''write'''''. Наверное это очень неприятно, когда, во время работы над текстовым файлом, в окне терминала, прямо среди текста, вдруг появляется предложение заказать пиццу. Поэтому, при работе в многопользовательской системе, вам наверняка захочется отключить доступ к своему терминалу. 
<big>'''wall'''</big> 
Имя этой команды — аббревиатура от "write all", т.е., передать сообщение всем пользователям на все терминалы в сети. Это, в первую очередь, инструмент администратора, который можно использовать, например, для оповещения всех пользователей о предстоящей, в ближайшее время, перезагрузке системы. 
<source lang="bash">
bash$ wall System going down for maintenance in 5 minutes!
Broadcast message from bozo (pts/1) Sun Jul 8 13:53:27 2001...
System going down for maintenance in 5 minutes!
</source> 
Если доступ к терминалу был закрыт командой '''''mesg''''', то сообщение на этом терминале выводиться не будет.
<big>'''dmesg'''</big> 
Выводит все сообщения, выдаваемые системой во время загрузки на ''stdout''. Очень полезная утилита для отладочных целей. Вывод '''''dmesg''''' может анализироваться с помощью [[grep]], [[sed]] или [[awk]] внутри сценария. 
<source lang="bash">
bash$ dmesg | grep hda
Kernel command line: ro root=/dev/hda2
hda: IBM-DLGA-23080, ATA DISK drive
hda: 6015744 sectors (3080 MB) w/96KiB Cache, CHS=746/128/63
hda: hda1 hda2 hda3 < hda5 hda6 hda7 > hda4
</source> 
'''Информационные и статистические утилиты''' 
<big>'''uname'''</big> 
Выводит на ''stdout'' имя системы. С ключом ''-a'', выводит подробную информацию, содержащую имя системы, имя узла (то есть имя, под которым система известна в сети), версию операционной системы, наименование модификации операционной системы, аппаратную архитектуру.
<source lang="bash">
bash$ uname -a
Linux localhost.localdomain 2.2.15-2.5.0 #1 Sat Feb 5 00:13:43 EST 2000 i686 unknown
bash$ uname -s
Linux
</source> 
<big>'''arch'''</big> 
Выводит тип аппаратной платформы компьютера. Эквивалентна команде '''''uname -m'''''.
<source lang="bash">
bash$ arch
i686
bash$ uname -m
i686
</source> 
<big>'''lastcomm'''</big> 
Выводит информацию, о ранее выполненных командах, из файла ''/var/account/pacct''. Дополнительно могут указываться команда и пользователь. Это одна из утилит пакета ''GNU acct''. 
<big>'''lastlog'''</big> 
Выводит список всех пользователей, с указанием времени последнего входа в систему. Данные берутся из файла ''/var/log/lastlog''.
<source lang="bash">
bash$ lastlog
root tty1 Fri Dec 7 18:43:21 -0700 2001
bin **Never logged in**
daemon **Never logged in**
...
bozo tty1 Sat Dec 8 21:14:29 -0700 2001

bash$ lastlog | grep root
root tty1 Fri Dec 7 18:43:21 -0700 2001
</source> 
Исполнение этой команды будет завершаться неудачей, если пользователь, вызвавший утилиту, не имеет прав на чтение файла ''/var/log/lastlog''. 
<big>'''lsof'''</big> 
Выводит детальный список открытых, в настоящий момент времени, файлов в виде таблицы. В таблице указаны — владелец файла, размер файла, тип файла, процесс, открывший файл, и многое другое. Само собой разумеется, что вывод команды '''''lsof''''' может быть обработан, в конвейере, с помощью утилит [[grep]] и/или [[awk]].
<source lang="bash">
bash$ lsof
COMMAND PID USER FD TYPE DEVICE SIZE NODE NAME
init 1 root mem REG 3,5 30748 30303 /sbin/init
init 1 root mem REG 3,5 73120 8069 /lib/ld-2.1.3.so
init 1 root mem REG 3,5 931668 8075 /lib/libc-2.1.3.so
cardmgr 213 root mem REG 3,5 36956 30357 /sbin/cardmgr
...
</source> 
<big>'''strace'''</big> 
Диагностическая и отладочная утилита, предназначенная для трассировки системных вызовов и сигналов. В простейшем случае, запускается как: '''''strace''''' ''COMMAND''. 
<source lang="bash">
bash$ strace df
execve("/bin/df", ["df"], [/* 45 vars */]) = 0
uname({sys="Linux", node="bozo.localdomain", ...}) = 0
brk(0) = 0x804f5e4
...
</source> 
Эквивалентна команде '''''truss'''''. 
<big>'''nmap'''</big> 
Сканер сетевых портов. Эта утилита сканирует сервер в поисках открытых портов и сервисов. Это очень важный инструмент, используемый для поиска уязвимостей при настройке системы.
<source lang="bash">
#!/bin/bash
SERVER=$HOST # localhost.localdomain (127.0.0.1).
PORT_NUMBER=25 # порт службы SMTP.
nmap $SERVER | grep -w "$PORT_NUMBER" # Проверить — открыт ли данный порт?
# grep -w — поиск только целых слов,
# так, например, порт 1025 будет пропущен.
exit 0
# 25/tcp open smtp
</source> 
<big>'''free'''</big> 
Показывает информацию об использовании памяти, в табличной форме. Вывод команды может быть проанализирован с помощью [[grep]], [[awk]] или ''Perl''. Команда '''''procinfo''''' тоже выводит эту информацию, среди всего прочего.
<source lang="bash">
bash$ free
total used free shared buffers cached
Mem: 30504 28624 1880 15820 1608 16376
-/+ buffers/cache: 10640 19864
Swap: 68540 3128 65412
</source> 
Показать размер неиспользуемой памяти RAM: 
<source lang="bash">
bash$ free | grep Mem | awk '{ print $4 }'
bash$ free -h | grep Mem | awk '{ print $4 }'
</source> 
<big>'''procinfo'''</big> 
Извлекает и выводит информацию из файловой системы ''/proc''. 
<source lang="bash">
bash$ procinfo | grep Bootup
Bootup: Wed Mar 21 15:15:50 2001 Load average: 0.04 0.21 0.34 3/47 6829
</source> 
<big>'''lsdev'''</big> 
Список аппаратных устройств в системе. 
<source lang="bash">
bash$ lsdev
Device DMA IRQ I/O Ports
------------------------------------------------
cascade 4 2
dma 0080-008f
dma1 0000-001f
dma2 00c0-00df
fpu 00f0-00ff
ide0 14 01f0-01f7 03f6-03f6
...
</source> 
<big>'''du'''</big> 
Выводит сведения о занимаемом дисковом пространстве в каталоге и вложенных подкаталогах. Если каталог не указан, то по-умолчанию выводятся сведения о текущем каталоге. 
<source lang="bash">
bash$ du -ach
1.0k ./wi.sh
1.0k ./tst.sh
1.0k ./random.file
6.0k .
6.0k total
</source> 
<big>'''df'''</big> 
Выводит в табличной форме сведения о смонтированных файловых системах. 
<source lang="bash">
bash$ df
Filesystem 1k-blocks Used Available Use% Mounted on
/dev/hda5 273262 92607 166547 36% /
/dev/hda8 222525 123951 87085 59% /home
/dev/hda7 1408796 1075744 261488 80% /usr
</source> 
<big>'''stat'''</big> 
Даёт подробную информацию о заданном файле (каталоге или файле устройства) или наборе файлов. 
<source lang="bash">
bash$ stat test.cru
File: "test.cru"
Size: 49970 Allocated Blocks: 100 Filetype: Regular File
Mode: (0664/-rw-rw-r--) Uid: ( 501/ bozo) Gid: ( 501/ bozo)
Device: 3,8 Inode: 18185 Links: 1
Access: Sat Jun 2 16:40:24 2001
Modify: Sat Jun 2 16:40:24 2001
Change: Sat Jun 2 16:40:24 2001
</source> 
Если заданный файл отсутствует, то '''''stat''''' вернёт сообщение об ошибке.
<source lang="bash">
bash$ stat nonexistent-file
nonexistent-file: No such file or directory
</source> 
<big>'''vmstat'''</big> 
Выводит информацию о виртуальной памяти. 
<source lang="bash">
bash$ vmstat
procs memory swap io system cpu
r b w swpd free buff cache si so bi bo in cs us sy id
0 0 0 0 11040 2636 38952 0 0 33 7 271 88 8 3 89
</source> 
<big>'''netstat'''</big> 
Показывает сведения о сетевой подсистеме, такие как: таблицы маршрутизации и активные соединения. Эта утилита получает сведения из ''/proc/net''. '''''netstat -r''''' — эквивалентна команде '''''route'''''. 
<big>'''uptime'''</big> 
Показывает количество времени, прошедшего с момента последней перезагрузки системы. 
<source lang="bash">
bash$ uptime
10:28pm up 1:57, 3 users, load average: 0.17, 0.34, 0.27
</source> 
<big>'''hostname'''</big> 
Выводит имя узла (сетевое имя системы). С помощью этой команды устанавливается сетевое имя системы в сценарии ''/etc/rc.d/rc.sysinit''. Эквивалентна команде '''''uname -n''''' и внутренней переменной $HOSTNAME 
<source lang="bash">
bash$ hostname
localhost.localdomain
bash$ echo $HOSTNAME
localhost.localdomain
</source> 
<big>'''hostid'''</big> 
Выводит 32-битный шестнадцатиричный идентификатор системы.
<source lang="bash">
bash$ hostid
7f0100
</source> 
Эта команда генерирует "уникальный" числовой идентификатор системы. Некоторые программные продукты используют этот идентификатор в процедуре регистрации. К сожалению, при генерации идентификатора, '''''hostid''''' использует только IP адрес системы, переводя его в шестнадцатиричное представление и переставляя местами пары байт.
Обычно, IP адрес системы можно найти в файле ''/etc/hosts''.
<source lang="bash">
bash$ cat /etc/hosts
127.0.0.1 localhost.localdomain localhost
</source> 
Переставив местами байты, попарно, в начальном адресе 127.0.0.1, мы получим 0.127.1.0, в шестнадцатиричном представлении это будет 007f0100, что вточности совпадает с приведённым выше результатом выполнения '''''hostid'''''. Наверняка можно найти несколько миллионов компьютеров с таким же "уникальным" идентификатором. 
<big>'''sar'''</big> 
Команда '''''sar''''' (System Activity Reporter) выводит очень подробную статистику о функционировании операционной системы. В июне 1999 года, компания Santa Cruz Operation(SCO) опубликовала исходные тексты утилиты. Она, как правило, не входит в базовый комплект пакетов Linux-систем. Но её можно получить в составе пакета ''sysstat utilities'', автор: ''Sebastien Godard''.
<source lang="bash">
bash$ sar
Linux 2.4.9 (brooks.seringas.fr) 09/26/03
10:30:00 CPU %user %nice %system %iowait %idle
10:40:00 all 2.21 10.90 65.48 0.00 21.41
10:50:00 all 3.36 0.00 72.36 0.00 24.28
11:00:00 all 1.12 0.00 80.77 0.00 18.11
Average: all 2.23 3.63 72.87 0.00 21.27

14:32:30 LINUX RESTART

15:00:00 CPU %user %nice %system %iowait %idle
15:10:00 all 8.59 2.40 17.47 0.00 71.54
15:20:00 all 4.07 1.00 11.95 0.00 82.98
15:30:00 all 0.79 2.94 7.56 0.00 88.71
Average: all 6.33 1.70 14.71 0.00 77.26
</source> 
<big>'''readelf'''</big> 
Показывает сведения о заданном бинарном файле формата ''elf''. Входит в состав пакета ''binutils''. 
<source lang="bash">
bash$ readelf -h /bin/bash
ELF Header:
Magic: 7f 45 4c 46 01 01 01 00 00 00 00 00 00 00 00 00
Class: ELF32
Data: 2`s complement, little endian
Version: 1 (current)
OS/ABI: Unix - System V
ABI Version: 0
Type: EXEC (Executable file)
. . .
</source> 
<big>'''size'''</big> 
Команда '''''size [/path/to/binary]''''' выведет информацию о размерах различных сегментов в исполняемых или библиотечных файлах. В основном используется программистами.
<source lang="bash">
bash$ size /bin/bash
text data bss dec hex filename
495971 22496 17392 535859 82d33 /bin/bash
</source> 
'''Системный журнал''' 
<big>'''logger'''</big> 
Добавляет в системный журнал (''/var/log/messages'') сообщение от пользователя. Для добавления сообщения пользователь не должен обладать привилегиями суперпользователя.
<source lang="bash">
bash$ logger Experiencing instability in network connection at 23:10, 05/21.
# Теперь попробуйте дать команду 'tail /var/log/messages'.
</source> 
Встраивая вызов '''''logger''''' в сценарии, вы получаете возможность заносить отладочную информацию в системный журнал ''/var/log/messages''.
<source lang="bash">
bash$ logger -t $0 -i Logging at line "$LINENO".
# Ключ "-t" задаёт тэг записи в журнале.
# Ключ "-i" — записывает ID процесса.

# tail /var/log/message
# ...
# Jul 7 20:48:58 localhost ./test.sh[1712]: Logging at line 3.
</source> 
<big>'''logrotate'''</big> 
Эта утилита производит манипуляции над системным журналом: ротация, сжатие, удаление и/или отправляет его по электронной почте, по мере необходимости. Как правило, утилита '''''logrotate''''' вызывается демоном '''''cron''''' ежедневно. Добавляя соответствующие строки в ''/etc/logrotate.conf'', можно заставить '''''logrotate''''' обрабатывать не только системный журнал, но и ваш личный. 
'''Управление заданиями''' 
<big>'''ps'''</big> 
'''''P'''''rocess '''''S'''''tatistics: Список исполняющихся в данный момент процессов. Обычно вызывается с ключами ''ax'', вывод команды может быть обработан командами [[grep]] или [[sed]], с целью поиска требуемого процесса.
<source lang="bash">
bash$ ps ax | grep sendmail
295 ? S 0:00 sendmail: accepting connections on port 25
</source> 
<big>'''pstree'''</big> 
Список исполняющихся процессов в виде "дерева". С ключом -p — вместе с именами процессов отображает их ''PID''. 
<big>'''top'''</big> 
Выводит список наиболее активных процессов. С ключом ''-b'' — отображение ведется в обычном текстовом режиме, что даёт возможность анализа вывода от команды внутри сценария.
<source lang="bash">
bash$ top -b
8:30pm up 3 min, 3 users, load average: 0.49, 0.32, 0.13
45 processes: 44 sleeping, 1 running, 0 zombie, 0 stopped
CPU states: 13.6% user, 7.3% system, 0.0% nice, 78.9% idle
Mem: 78396K av, 65468K used, 12928K free, 0K shrd, 2352K buff
Swap: 157208K av, 0K used, 157208K free 37244K cached

PID USER PRI NI SIZE RSS SHARE STAT %CPU %MEM TIME COMMAND
848 bozo 17 0 996 996 800 R 5.6 1.2 0:00 top
1 root 8 0 512 512 444 S 0.0 0.6 0:04 init
2 root 9 0 0 0 0 SW 0.0 0.0 0:00 keventd
...
</source> 
<big>'''nice'''</big> 
Запускает фоновый процесс с заданным приоритетом. Приоритеты могут задаваться числом из диапазона от '''''19''''' (''низший приоритет'') до '''''-20''''' (''высший приоритет''). Но только '''''root''''' может указать значение приоритета меньше нуля (отрицательные значения). См. так же команды '''''renice''''', '''''snice''''' и '''''skill'''''. 
<big>'''nohup'''</big> 
Запуск команд в режиме игнорирования сигналов прерывания и завершения, что предотвращает завершение работы команды даже если пользователь, запустивший её, вышел из системы. Если после команды не указан символ '''''&''''', то она будет исполняться как процесс "переднего плана". Если вы собираетесь использовать '''''nohup''''' в сценариях, то вам потребуется использовать его в связке с командой '''''wait''''', чтобы не породить процесс "зомби". 
<big>'''pidof'''</big> 
Возвращает идентификатор процесса (''pid'') по его имени. Поскольку многие команды управления процессами, такие как '''''kill''''' и '''''renice''''', требуют указать ''pid'' процесса, а не его имя, то '''''pidof''''' может сослужить неплохую службу при идентификации процесса по его имени. Эта команда может рассматриваться как приблизительный эквивалент внутренней переменной $PPID .
<source lang="bash">
bash$ pidof xclock
880
</source> 
 '''Пример''': '''''Использование команды pidof при остановке процесса.'''''
<source lang="bash">
#!/bin/bash
# kill-process.sh
NOPROCESS=2
process=xxxyyyzzz # Несуществующий процесс.
# Только в демонстрационных целях...
# ... чтобы не уничтожить этим сценарием какой-нибудь процесс.
#
# Если с помощью этого сценария вы задумаете разрывать связь с Internet, то process=pppd
t=`pidof $process` # Поиск pid (process id) процесса $process.
# pid требует команда 'kill' (невозможно остановить процесс, указав его имя).

if [ -z "$t" ] # Если процесс с таким именем не найден, то 'pidof' вернет null.
then
echo "Процесс $process не найден."
exit $NOPROCESS
fi
kill $t # В некоторых случаях может потребоваться 'kill -9'.
# Здесь нужно проверить — был ли уничтожен процесс.
# Возможно так: " t=`pidof $process` ".
# Этот сценарий мог бы быть заменён командой
# kill $(pidof -x process_name)
# но это было бы не так поучительно.
exit 0
</source> 
<big>'''fuser'''</big> 
Возвращает идентификаторы процессов, использующих указанный файл(ы) или каталог. С ключом ''-k'', завершает найденные процессы. Может с успехом использоваться для защиты системы, особенно в сценариях разграничения доступа к системным службам. 
<big>'''cron'''</big> 
Планировщик заданий. С его помощью выполняются такие задачи, как очистка и удаление устаревших файлов системных журналов, обновление базы данных ''slocate''. Это суперпользовательская версия команды '''''at''''' (хотя любой пользователь может создать собственную таблицу ''crontab''). Эта утилита запускается как фоновый процесс-daemon и выполняет задания, находящиеся в файле ''/etc/crontab''. В некоторых дистрибутивах Linux, в качестве ''crond'' используется версия '''''cron''''' от ''Matthew Dillon''. 
'''Управление процессами и загрузкой''' 
<big>'''init'''</big> 
init — предок (родитель) всех процессов в системе. Вызывается на последнем этапе загрузки системы и определяет уровень загрузки (''runlevel'') из файла ''/etc/inittab''. 
<big>'''telinit'''</big> 
Символическая ссылка на '''''init''''' — инструмент для смены уровня загрузки (''runlevel''), как правило используется при обслуживании системы или восстановлении файловой системы. Может быть вызвана только суперпользователем. Эта команда может быть очень опасна, при неумелом обращении — прежде чем использовать её, убедитесь в том, что вы совершенно точно понимаете что делаете! 
<big>'''runlevel'''</big> 
Выводит предыдущий и текущий уровни загрузки (''runlevel''). Уровень загрузки может иметь одно из 6 значений: '''''0''''' — остановка системы, '''''1''''' — однопользовательский режим, '''''2''''' или '''''3''''' — многопользовательский режим, '''''5''''' — многопользовательский режим и запуск X Window, '''''6''''' — перезагрузка. Уровни загрузки определяются из файла ''/var/run/utmp''. 
<big>'''halt,shutdown,reboot'''</big> 
Набор команд для остановки системы, обычно перед выключением питания. 
'''Команды для работы с сетью''' 
<big>'''ifconfig'''</big> 
Утилита конфигурирования и запуска сетевых интерфейсов. Чаще всего используется в сценариях начальной загрузки системы, для настройки и запуска сетевых интерфейсов или для их остановки перед остановкой или перезагрузкой. 
<source lang="bash">
# Фрагменты кода из /etc/rc.d/init.d/network
# ...
# Проверка сетевой полсистемы.
[ ${NETWORKING} = "no" ] && exit 0
[ -x /sbin/ifconfig ] || exit 0
# ...
for i in $interfaces ; do
if ifconfig $i 2>/dev/null | grep -q "UP" >/dev/null 2>&1 ; then
action "Останавливается $i: " ./ifdown $i boot
fi
# Ключ "-q", характерный для GNU-версии "grep", означает "quiet" ("молча"), т.е. подавляет вывод.
# Поэтому нет необходимости переадресовывать вывод на /dev/null.
# ...
echo "В настоящее время активны устройства:"
echo `/sbin/ifconfig | grep ^[a-z] | awk '{print $1}'`
# ^^^^^ скобки необходимы для предотвращения подстановки имён файлов (globbing).
# Следующий код делает то же самое.
# echo $(/sbin/ifconfig | awk '/^[a-z]/ { print $1 })'
# echo $(/sbin/ifconfig | sed -e 's/ .*//')
# Спасибо S.C. за комментарии.
</source> 
<big>'''iwconfig'''</big> 
Эта команда используется для настройки беспроводной (wireless) сети. Представляет собой эквивалент команды '''''ifconfig''''', описанной выше. 
<big>'''route'''</big> 
Выводит сведения о таблице маршрутизации ядра или вносит туда изменения.
<source lang="bash">
bash$ route
Destination Gateway Genmask Flags MSS Window irtt Iface
pm3-67.bozosisp * 255.255.255.255 UH 40 0 0 ppp0
127.0.0.0 * 255.0.0.0 U 40 0 0 lo
default pm3-67.bozosisp 0.0.0.0 UG 40 0 0 ppp0
</source> 
<big>'''chkconfig'''</big> 
Проверка сетевой конфигурации. Обслуживает список, запускаемых на этапе загрузки, сетевых сервисов, список сервисов хранится в каталогах /etc/rc?.d (строго говоря, chkconfig работает не только с сетевыми сервисами, а с сервисами вообще, не зависимо от того сетевые это службы или нет — прим. перев.). Изначально эта утилита была перенесена в ''Red Hat Linux'' из ОС ''IRIX'', '''''chkconfig''''' входит в состав далеко не всех дистрибутивов Linux.
<source lang="bash">
bash$ chkconfig --list
atd 0:off 1:off 2:off 3:on 4:on 5:on 6:off
rwhod 0:off 1:off 2:off 3:off 4:off 5:off 6:off
...
</source> 
<big>'''tcpdump'''</big> 
"Сниффер" ("sniffer") сетевых пакетов. Инструмент для перехвата и анализа сетевого трафика по определенным критериям. Дамп трафика ip-пакетов между двумя узлами сети — ''bozoville'' и ''caduceus'':
<source lang="bash">
bash$ tcpdump ip host bozoville and caduceus
</source> 
Конечно же, вывод команды '''''tcpdump''''' может быть проанализирован с помощью команд обработки текста, обсуждавшихся выше.
'''Команды для работы с файловыми системами''' 
<big>'''mount'''</big> 
Выполняет монтирование файловой системы, обычно на устройстве со сменными носителями, такими как дискеты или CDROM. Файл ''/etc/fstab'' содержит перечень доступных для монтирования файловых систем, разделов и устройств, включая опции монтирования, благодаря этому файлу, монтирование может производиться автоматически или вручную. Файл ''/etc/mtab'' содержит список смонтированных файловых систем и разделов (включая виртуальные, такие как ''/proc''). 
'''''mount -a''''' — монтирует все (all) файловые системы и разделы, перечисленные в ''/etc/fstab'', за исключением тех, которые имеют флаг ''noauto''. Эту команду можно встретить в сценариях начальной загрузки системы из ''/etc/rc.d'' (''rc.sysinit'' или нечто похожее).
<source lang="bash">
mount -t iso9660 /dev/cdrom /mnt/cdrom
# Монтирование CDROM
mount /mnt/cdrom
# Более короткий и удобный вариант, если точка монтирования /mnt/cdrom описана в /etc/fstab
</source> 
Эта команда может даже смонтировать обычный файл как блочное устройство. Достигается это за счёт связывания файла с loopback-устройством. Эту возможность можно использовать для проверки ''ISO9660'' образа компакт-диска перед его записью на болванку.
 '''Пример''': '''''Проверка образа CD.'''''
<source lang="bash">
# С правами root...
mkdir /mnt/cdtest # Подготовка точки монтирования.
mount -r -t iso9660 -o loop cd-image.iso /mnt/cdtest # Монтирование образа диска.
# ключ "-o loop" эквивалентен "losetup /dev/loop0"
cd /mnt/cdtest # Теперь проверим образ диска.
ls -alR # Вывод списка файлов
</source> 
<big>'''umount'''</big> 
Отмонтирует смонтированную файловую систему. Перед тем как физически вынуть компакт-диск или дискету из устройства, это устройство должно быть отмонтировано командой '''''umount''''', иначе файловая система может оказаться поврежденной (особенно это относится к накопителям на гибких магнитных дисках, прим. перев.).
<source lang="bash">
umount /mnt/cdrom # Теперь вы можете извлечь диск из привода.
</source> 
Утилита '''''automount''''', если она установлена, может выполнять автоматическое монтирование/размонтирование устройств со сменными носителями, такие как дискеты и компакт-диски. На ноутбуках со сменными устройствами FDD и CD-ROM, такой подход может привести к возникновению определённых проблем. 
<big>'''sync'''</big> 
Принудительный сброс содержимого буферов на жесткий диск (синхронизация содержимого буферов ввода-вывода и устройства-носителя). Несмотря на то, что нет такой уж острой необходимости в этой утилите, тем не менее '''''sync''''' придаёт уверенности системным администраторам или пользователям в том, что их данные будут сохранены на жёстком диске, и не будут потеряны в случае какого-либо сбоя. В былые дни, команда '''''sync; sync''''' (дважды — для абсолютной уверенности) была упреждающей мерой перед перезагрузкой системы. Иногда возникает необходимость принудительной синхронизации буферов ввода-вывода с содержимым на магнитном носителе, как, например, при надежном удалении файла или когда наблюдаются скачки напряжения в сети электроснабжения. 
<big>'''losetup'''</big> 
Устанавливает и конфигурирует loopback-устройства .
 '''Пример''': '''''Создание файловой системы в обычном файле.'''''
<source lang="bash">
SIZE=1048576 # 1 Мб
head -c $SIZE < /dev/zero > file # Создаётся файл нужного размера.
losetup /dev/loop0 file # Файл назначается как loopback-устройство.
mke2fs /dev/loop0 # Создание файловой системы.
mount -o loop /dev/loop0 /mnt # Монтирование только что созданной файловой системы.
# Спасибо S.C.
</source> 
<big>'''mkswap'''</big> 
Создание swap-раздела или swap-файла. Созданный swap-раздел (файл) нужно затем подключить командой '''''swapon'''''. 
<big>'''swapon,swapoff'''</big> 
Разрешает/запрещает использование swap-раздела (файла). Эта команда обычно используется во время загрузки системы или во время остановки. 
<big>'''mke2fs'''</big> 
Создает файловую систему ''ext2''. Должна вызываться с правами суперпользователя. 
 '''Пример''': '''''Добавление нового жёсткого диска.'''''
<source lang="bash">
#!/bin/bash # Добавление в систему второго жёсткого диска.
# Программное конфигурирование. Предполагается, что устройство уже подключено к аппаратуре компьютера.
# Взято из статьи автора документа.
# "Linux Gazette", выпуск #38, http://www.linuxgazette.com.

ROOT_UID=0 # Этот сценарий должен запускать только root.
E_NOTROOT=67 # Код ошибки, если сценарий запущен простым пользователем.

if [ "$UID" -ne "$ROOT_UID" ]
then
echo "Для запуска этого сценария вы должны обладать правами root."
exit $E_NOTROOT
fi # Будьте крайне осторожны!
# Если что-то пойдёт не так, то вы можете потерять текущую файловую систему.

NEWDISK=/dev/hdb # Предполагается, что /dev/hdb — это новое устройство. Проверьте!
MOUNTPOINT=/mnt/newdisk # Или выберите иное устройство для монтирования.
fdisk $NEWDISK
mke2fs -cv $NEWDISK1 # Проверка на "плохие" блоки (bad blocks) и подробный вывод.
# Обратите внимание: /dev/hdb1, *не* то же самое, что /dev/hdb!
mkdir $MOUNTPOINT
chmod 777 $MOUNTPOINT # Сделать новое устройство доступным для всех пользователей.
# Теперь проверим...
# mount -t ext2 /dev/hdb1 /mnt/newdisk
# Попробуйте создать каталог.
# Если получилось — отмонтируйте устройство и продолжим.
# Последний штрих:
# Добавьте следующую строку в /etc/fstab.
# /dev/hdb1 /mnt/newdisk ext2 defaults 1 1
exit 0
</source> 
<big>'''tune2fs'''</big> 
Настройка отдельных параметров файловой системы ''ext2'', например счётчик максимального количества монтирований без проверки. Должна вызываться с привилегиями пользователя ''root''.
Очень опасная утилита~ Вы можете использовать её только на свой страх и риск,поскольку, по неосторожности, вы запросто можете разрушить файловую систему. 
<big>'''dumpe2fs'''</big> 
Выводит на ''stdout'' очень подробную информацию о файловой системе. Должна вызываться с привилегиями пользователя ''root''.
<source lang="bash">
root# dumpe2fs /dev/hda7 | grep 'ount count'
dumpe2fs 1.19, 13-Jul-2000 for EXT2 FS 0.5b, 95/08/09
Mount count: 6
Maximum mount count: 20
</source> 
<big>'''hdparm'''</big> 
Выводит или изменяет параметры настройки жёсткого диска. Должна вызываться с привилегиями пользователя ''root''. Потенциально опасна при неправильном использовании. 
<big>'''fdisk'''</big> 
Создание или изменение таблицы разделов на устройствах хранения информации, обычно — жёстких дисках. Должна вызываться с привилегиями пользователя ''root''. Пользуйтесь этой утилитой с особой осторожностью, т.к. при неправильном использовании можно легко разрушить существующую файловую систему! 
<big>'''fsck,e2fsck,debugfs'''</big> 
Набор команд для проверки, восстановления и отладки файловой системы.
'''''fsck''''': интерфейсная утилита для проверки файловых систем в Unix (может вызывать другие утилиты проверки). 
'''''e2fsck''''': проверка файловой системы ''ext2''. 
'''''debugfs''''': отладчик файловой системы ''ext2''. Одно из применений этой универсальной (и опасной!) утилиты — это восстановление удалённых файлов. Только для опытных пользователей! 
Все эти утилиты должны вызываться с привилегиями пользователя ''root''. При неправильном использовании, любая из них может разрушить файловую систему! 
<big>'''badblocks'''</big> 
Выполняет поиск плохих блоков (физические повреждения носителей) на устройствах хранения информации. Эта команда может использоваться для поиска плохих блоков при форматировании вновь устанавливаемых жёстких дисков или для проверки устройств резервного копирования.Например, '''''badblocks /dev/fd0''''', проверит дискету на наличие
повреждённых блоков. Утилита '''''badblocks''''' может быть вызвана в деструктивном (проверка осуществляется путём записи некоторого шаблона в каждый блок, а затем производится попытка чтения этого блока) или в недеструктивном (неразрушающем — только чтение) режиме. 
<big>'''lsusb,usbmodules'''</big> 
Команда '''''lsusb''''' выводит сведения о имеющихся в системе шинах USB (Universal Serial Bus) и подключенных к ним устройствах. 
Команда '''''usbmodules''''' выводит информацию о модулях драйверов присоединенных USB-устройств. 
<source lang="bash">
root# lsusb
Bus 001 Device 001: ID 0000:0000
Device Descriptor:
bLength 18
bDescriptorType 1
bcdUSB 1.00
bDeviceClass 9 Hub
bDeviceSubClass 0
bDeviceProtocol 0
bMaxPacketSize0 8
idVendor 0x0000
idProduct 0x0000
. . .
</source> 
<big>'''mkbootdisk'''</big> 
Создание загрузочной дискеты, которая может быть использована для загрузки системы, если, например, была повреждена MBR (''master boot record'' — главная загрузочная запись). Команда '''''mkbootdisk''''' — это сценарий на языке командной оболочки Bash, автор: ''Erik Troan'', располагается в каталоге ''/sbin''. 
<big>'''chroot'''</big> 
'''''CH'''''ange '''''ROOT''''' — смена корневого каталога. Обычно, команды и утилиты ориентируются в файловой системе посредством переменной $PATH , относительно корневого каталога / . Команда '''''chroot''''' изменяет корневой каталог по-умолчанию на другой (рабочий каталог также изменяется). Эта утилита, как правило, используется с целью защиты системы, например, с её помощью можно ограничить доступ к разделам файловой системы для пользователей, подключающихся к системе с помощью '''''telnet''''' (это называется — "поместить пользователя в chroot окружение"). Обратите внимание: после выполнения команды '''''chroot''''' изменяется путь к исполняемым файлам системы. 
Команда '''''chroot /opt''''' приведёт к тому, что все обращения к каталогу ''/usr/bin'' будут переводиться на каталог ''/opt/usr/bin''. Аналогично, '''''chroot /aaa/bbb /bin/ls''''' будет пытаться вызвать команду [[ls]] из каталога ''/aaa/bbb/bin'', при этом, корневым каталогом для [[ls]] станет каталог ''/aaa/bbb''. Поместив строчку ''alias XX 'chroot /aaa/bbb ls' '' в пользовательский ''~/.bashrc'', можно эффективно ограничить доступ команде "XX", запускаемой пользователем, к разделам файловой системы. При изменении корневого каталога, вам наверняка потребуется скопировать системные утилиты и разделяемые библиотеки в новый корневой каталог, поскольку после смены корневого каталога, директории с системными утилитами могут оказаться за пределами нового корневого каталога. 
<big>'''lockfile'''</big> 
Эта утилита входит в состав пакета ''procmail'' (www.procmail.org). Она создаёт ''lock file'', файл-семафор (или, если угодно, файл блокировки), который управляет доступом к заданному файлу, устройству или ресурсу. ''Lock file'' служит признаком того, что данный файл, устройство или ресурс "занят" некоторым процессом, и ограничивает (или вообще запрещает) доступ к ресурсу другим процессам. 
Файлы блокировок широко применяются для защиты системных почтовых каталогов от одновременной записи несколькими пользователями, для индикации занятости порта модема, и т.п. Сценарии могут использовать файлы блокировок для того, чтобы выяснить — запущен ли тот или иной процесс. Обратите внимание: если в сценарии будет предпринята попытка создать файл блокировки, когда он уже существует, то такой сценарий скорее всего зависнет. Как правило, файлы блокировки создаются в каталоге ''/var/lock''. Проверка наличия файла блокировки может быть проверена примерно таким образом:
<source lang="bash">
appname=xyzip
# Приложение "xyzip" создает файл блокировки "/var/lock/xyzip.lock".
if [ -e "/var/lock/$appname.lock ]
then
...
</source> 
<big>'''mknod'''</big> 
Создаёт специальный файл для блочного или символьного устройства (может потребоваться при установке новых устройств в компьютер). В системе имеется более удобная в обращении утилита '''''MAKEDEV''''', которая обладает всей функциональностью команды '''''mknod'''''. 
<big>'''tmpwatch'''</big> 
Автоматически удаляет файлы, к которым не было обращений в течение заданного периода времени. Обычно вызывается демоном '''''cron''''' для удаления устаревших файлов системного журнала. 
<big>'''MAKEDEV'''</big> 
Утилита предназначена для создания файлов-устройств. Должна запускаться с привилегиями пользователя ''root'', в каталоге ''/dev''.
<source lang="bash">
root# ./MAKEDEV
</source> 
Это своего рода расширенная версия утилиты '''''mknod'''''. 
'''Команды резервного копирования''' 
<big>'''dump,restore'''</big> 
Команда '''''dump''''' создаёт резервные копии целых файловых систем, обычно используется в крупных системах и сетях. Она считывает дисковые разделы и сохраняет их в файле, в двоичном формате. Созданные таким образом файлы, могут быть сохранены на каком-либо носителе — на жёстком диске или магнитной ленте. Команда '''''restore''''' — "разворачивает" файлы, созданные утилитой '''''dump'''''. 
<big>'''fdformat'''</big> 
Выполняет низкоуровневое форматирование дискет. 
'''Команды управления системными ресурсами''' 
<big>'''ulimit'''</big> 
Устанавливает верхний предел для системных ресурсов. Как правило вызывается с ключом ''-f'', что означает наложение ограничений на размер файлов ('''''ulimit -f 1000''''' ограничит размер вновь создаваемых файлов одним мегабайтом). Ключ ''-c'' ограничивает размер файлов ''coredump'' ('''''ulimit -c 0''''' запретит создание coredump-файлов). Обычно, все ограничения прописываются в файле ''/etc/profile'' и/или ''~/.bash_profile''. Грамотное использование '''''ulimit''''' поможет избежать нападений, целью которых является исчерпание системных ресурсов, известных под названием ''fork bomb''.
<source lang="bash">
#!/bin/bash
# Этот сценарий служит исключительно демонстрационным целям!
# Запускайте его на свой страх и риск — он ПОДВЕСИТ вашу систему!
while true # Бесконечный цикл.
do
$0 & # Этот сценарий вызывает сам себя . . .
# порождая дочерние процессы бесконечное число раз . . .
# точнее — до тех пор, пока не иссякнут системные ресурсы.
done # Это печально известный сценарий "sorcerer's appentice".
exit 0 # Сценарий никогда не завершит свою работу.
</source> 
Команда '''''ulimit -Hu XX''''' (где ''XX'' — это верхний предел количества процессов, которые может запустить пользователь одновременно) в ''/etc/profile'' вызовет аварийное завершение этого сценария, когда количество процессов превысит установленный предел. 
<big>'''setquota'''</big> 
Команда управления дисковыми квотами для пользователей и групп. 
<big>'''umask'''</big> 
Установка маски режима создания файлов. Накладывает ограничения на атрибуты по-умолчанию для создаваемых файлов. Маска представляет собой восьмеричное значение и определяет запрещённые атрибуты файла. Например, '''''umask 022''''' удаляет права на запись для группы и прочих пользователей (у файлов, создававшихся с режимом ''777'', он оказывается равным ''755'', а режим ''666'' преобразуется в ''644'', т.е. ''777 NAND 022 = 755'', ''666 NAND 022 = 644''). Конечно же, в последствие, пользователь может откорректировать права доступа к своему файлу с помощью команды [[chmod]]. Как правило, значение '''''umask''''' устанавливается в файле ''/etc/profile'' и/или ''~/.bash_profile''. 
<big>'''rdev'''</big> 
Выводит или изменяет корневое устройство, размер RAM-диска или видео режим.Функциональные возможности утилиты '''''rdev''''' вообще повторяются загрузчиком ''lilo'', но '''''rdev''''' по прежнему остаётся востребованной, например, при установке электронного диска (RAM-диск).Это потенциально опасная, при неумелом использовании, утилита. 
'''Команды для работы с модулями ядра''' 
<big>'''lsmod'''</big> 
Выводит список загруженных модулей.
<source lang="bash">
bash$ lsmod
Module Size Used by
autofs 9456 2 (autoclean)
opl3 11376 0
serial_cs 5456 0 (unused)
sb 34752 0
uart401 6384 0 [sb]
sound 58368 0 [opl3 sb uart401]
soundlow 464 0 [sound]
soundcore 2800 6 [sb sound]
ds 6448 2 [serial_cs]
i82365 22928 2
</source> 
Команда '''''cat /proc/modules''''' выведет на экран эту же информацию. 
<big>'''insmod'''</big> 
Принудительная загрузка модуля ядра (старайтесь вместо '''''insmod''''' использовать команду '''''modprobe'''''). Должна вызываться с привилегиями пользователя ''root''. 
<big>'''rmmod'''</big> 
Выгружает модуль ядра. Должна вызываться с привилегиями пользователя ''root''. 
<big>'''modprobe'''</big> 
Загрузчик модулей, который обычно вызывается из сценариев начальной загрузки системы. Должна вызываться с привилегиями пользователя ''root''. 
<big>'''depmod'''</big> 
Создаёт файл зависимостей между модулями, обычно вызывается из сценариев начальной загрузки системы. 
<big>'''modinfo'''</big> 
Выводит сведения о загруженных модулях ядра.
<source lang="bash">
bash$ modinfo hid
filename: /lib/modules/2.4.20-6/kernel/drivers/usb/hid.o
description: "USB HID support drivers"
author: "Andreas Gal, Vojtech Pavlik <vojtech@suse.cz>"
license: "GPL"
</source> 
'''Прочие команды''' 
<big>'''env'''</big> 
Запускает указанную программу или сценарий с модифицированными переменными окружения(не изменяя среду системы в целом, изменения касаются только окружения запускаемой программы/сценария). Посредством [varname=xxx], устанавливает значение переменной окружения varname, которая будет доступна из запускаемой программы/сценария. Без параметров — просто выводит список переменных окружения с их значениями. В Bash, и других производных от Bourne shell, имеется возможность установки переменных окружения и запуска программы (или сценария) одной командной строкой. 
<source lang="bash">
var1=value1 var2=value2 commandXXX
# $var1 и $var2 — будут определены только в окружении для 'commandXXX'.
</source> 
В первой строке сценария ("sha-bang") можно указать команду env, если путь к командному интерпретатору не известен.
<source lang="bash">
#! /usr/bin/env perl
print "Этот сценарий, на языке программирования Perl, будет запущен,\n";
print "даже если я не знаю где в системе находится Perl.\n";
# Прекрасно подходит для написания кросс-платформенных сценариев,
# когда Perl может находиться совсем не там, где вы ожидаете.
# Спасибо S.C.
</source> 
<big>'''ldd'''</big> 
Выводит список разделяемых библиотек, необходимых для исполняемого файла. 
<source lang="bash">
bash$ ldd /bin/ls
libc.so.6 => /lib/libc.so.6 (0x4000c000)
/lib/ld-linux.so.2 => /lib/ld-linux.so.2 (0x80000000)
</source> 
<big>'''watch'''</big> 
Периодически запускает указанную программу с заданным интервалом времени. По-умолчанию интервал между запусками принимается равным 2 секундам, но может быть изменён ключом ''-n''.
<source lang="bash">
watch -n 5 tail /var/log/messages
# Выводит последние 10 строк из системного журнала, /var/log/messages, каждые пять секунд.
</source> 
<big>'''strip'''</big> 
Удаляет отладочную информацию из исполняемого файла. Это значительно уменьшает размер исполняемого файла, но при этом делает отладку программы невозможной. Эту команду часто можно встретить в Makefile-ах, и редко — в сценариях на языке командной оболочки. 
<big>'''nm'''</big> 
Выводит список символов (используемых в целях отладки), содержащихся в откомпилированном двоичном файле. 
<big>'''rdist'''</big> 
Позволяет на заданных машинах хранить идентичные копии файлов. По умолчанию, '''''rdist''''' просматривает только те файлы, версия которых на удалённых машинах более старая, чем на локальной машине. Это делается сравнением последнего времени модификации и размера файла на локальной машине и на удалённых. А теперь, используя полученные нами знания, попробуем разобраться с одним из системных сценариев. Один из самых коротких и простых — это '''''killall''''', который вызывается для остановки процессов при перезагрузке или выключении компьютера.
 '''Пример''': '''''Сценарий killall, из каталога /etc/rc.d/init.d .'''''
<source lang="bash">
#!/bin/sh
# --> Комментарии, начинающиеся с "# -->", добавлены автором документа.
# --> Этот сценарий является частью пакета 'rc'-сценариев
# --> Автор: Miquel van Smoorenburg, <miquels@drinkel.nl.mugnet.org>
# --> Этот сценарий характерен для дистрибутива Red Hat
# --> (в других дистрибутивах может отсутствовать).
# Остановить все ненужные сервисы которые еще работают (собственно, их уже не должно быть, это лишь формальная проверка, на всякий случай)

for i in /var/lock/subsys/*; do
# --> Стандартный заголовок цикла for/in, но, поскольку "do"
# --> находится в той же самой строке, что и for,
# --> необходимо разделить их символом ";".
# Проверяется наличие сценария.
[ ! -f $i ] && continue
# --> Очень интересное использование "И-списка", эквивалентно:
# --> if [ ! -f "$i" ]; then continue

# Получить имя подсистемы.
subsys=${i#/var/lock/subsys/}
# --> В данном случае совпадает с именем файла.
# --> Это точный эквивалент subsys=`basename $i`.
# --> Таким образом получается имя файла блокировки (если он присутствует,
# --> то это означает, что процесс запущен).
# --> См. описание команды "lockfile" выше.

# Остановить службу.
if [ -f /etc/rc.d/init.d/$subsys.init ]; then
/etc/rc.d/init.d/$subsys.init stop
else
/etc/rc.d/init.d/$subsys stop
# --> Останавливает задачу или демона
# --> посредством встроенной команды 'stop'.
fi
done
</source> 
В общем всё довольно понятно. Кроме хитрого манипулирования с переменными, при определении имени подсистемы(службы), здесь нет ничего нового. 
'''Упражнение 1'''. Просмотрите сценарий '''halt''' в каталоге ''/etc/rc.d/init.d''. Он по размеру немного больше, чем '''''killall''''', но придерживается той же концепции. Создайте копию этого сценария в своём домашнем каталоге и поэкспериментируйте с ним (НЕ запускайте его с привилегиями суперпользователя!). Попробуйте запустить его с ключами ''-vn'' ('''''sh -vn scriptname'''''). Добавьте свои комментарии. Замените действующие команды на "echo". 
'''Упражнение 2'''. Просмотрите другие, более сложные сценарии из ''/etc/rc.d/init.d''. Попробуйте разобраться в их работе. Проверьте их работу, следуя рекомендациям, приведённым выше. За дополнительной информацией вы можете обратиться к документу ''sysvinitfiles'' в каталоге ''/usr/share/doc/initscripts-?.??'', который входит в пакет документации к "initscripts".

== Подстановка команд ==
Подстановка команд — это подстановка результатов выполнения команды или даже серии команд; буквально, эта операция позволяет вызвать команду в другом окружении. Классический пример подстановки команд — использование обратных одиночных кавычек (`...`). Команды внутри этих кавычек представляют собой текст командной строки.
<source lang="bash">
script_name=`basename $0`
echo "Имя этого файла-сценария: $script_name."
</source> 
'''''Вывод от команд может использоваться: как аргумент другой команды, для установки значения переменной и даже для генерации списка аргументов цикла for.''''' 
<source lang="bash">
rm `cat filename` # здесь "filename" содержит список удаляемых файлов.
#
# S. C. предупреждает, что в данном случае может возникнуть ошибка "arg list too long".
# Такой вариант будет лучше: xargs rm -- < filename
# ( -- подходит для случая, когда "filename" начинается с символа "-" )

textfile_listing=`ls *.txt`
# Переменная содержит имена всех файлов *.txt в текущем каталоге.
echo $textfile_listing

textfile_listing2=$(ls *.txt) # Альтернативный вариант.
echo $textfile_listing2
# Результат будет тем же самым.

# Проблема записи списка файлов в строковую переменную состоит в том,
# что символы перевода строки заменяются на пробел.
#
# Как вариант решения проблемы -- записывать список файлов в массив.
# shopt -s nullglob # При несоответствии, имя файла игнорируется.
# textfile_listing=( *.txt )
#
# Спасибо S.C.
</source> 
Подставляемая команда выполняется в подоболочке. Подставляемая команда может получиться разбитой на отдельные слова. 
<source lang="bash">
COMMAND `echo a b` # 2 аргумента: a и b
COMMAND "`echo a b`" # 1 аргумент: "a b"
COMMAND `echo` # без аргументов
COMMAND "`echo`" # один пустой аргумент
# Спасибо S.C.
</source> 
Даже когда не происходит разбиения на слова, операция подстановки команд может удалять завершающие символы перевода строки. 
<source lang="bash">
# cd "`pwd`" # Должна выполняться всегда.
# Однако...
mkdir 'dir with trailing newline
'
cd 'dir with trailing newline
'
cd "`pwd`" # Ошибка:
# bash: cd: /tmp/dir with trailing newline: No such file or directory
cd "$PWD" # Выполняется без ошибки.

old_tty_setting=$(stty -g) # Сохранить настройки терминала.
echo "Нажмите клавишу "
stty -icanon -echo # Запретить "канонический" режим терминала.
# Также запрещает эхо-вывод.
key=$(dd bs=1 count=1 2> /dev/null) # Поймать нажатие на клавишу.
stty "$old_tty_setting" # Восстановить настройки терминала.
echo "Количество нажатых клавиш = ${#key}." # ${#variable} = количество символов в переменной $variable
#
# Нажмите любую клавишу, кроме RETURN, на экране появится "Количество нажатых клавиш = 1."
# Нажмите RETURN, и получите: "Количество нажатых клавиш = 0."
# Символ перевода строки будет "съеден" операцией подстановки команды.
Спасибо S.C.
</source> 
При выводе значений переменных, полученных в результате подстановки команд, командой '''''echo''''', без кавычек, символы перевода строки будут удалены. Это может оказаться неприятным сюрпризом. 
<source lang="bash">
dir_listing=`ls -l`
echo $dir_listing # без кавычек
# Вы наверно ожидали увидеть удобочитаемый список каталогов.

# Однако, вы получите:
# total 3 -rw-rw-r-- 1 bozo bozo 30 May 13 17:15 1.txt -rw-rw-r-- 1 bozo
# bozo 51 May 15 20:57 t2.sh -rwxr-xr-x 1 bozo bozo 217 Mar 5 21:13 wi.sh
# Символы перевода строки были заменены пробелами.

echo "$dir_listing" # в кавычках
# -rw-rw-r-- 1 bozo 30 May 13 17:15 1.txt
# -rw-rw-r-- 1 bozo 51 May 15 20:57 t2.sh
# -rwxr-xr-x 1 bozo 217 Mar 5 21:13 wi.sh
</source> 
Подстановка команд позволяет даже записывать в переменные содержимое целых файлов, с помощью перенаправления или команды [[cat]]. 
<source lang="bash">
variable1=`<file1` # Записать в переменную "variable1" содержимое файла "file1".
variable2=`cat file2` # Записать в переменную "variable2" содержимое файла "file2".
# Однако, эта команда порождает дочерний процесс,
# поэтому эта строка выполняется медленнее, чем предыдущая.
# Замечание:
# В переменные можно записать даже управляющие символы.

# Выдержки из системного файла /etc/rc.d/rc.sysinit (Red Hat Linux)

if [ -f /fsckoptions ]; then
fsckoptions=`cat /fsckoptions`
...
fi
#
#
if [ -e "/proc/ide/${disk[$device]}/media" ] ; then
hdmedia=`cat /proc/ide/${disk[$device]}/media`
...
fi
#
#
if [ ! -n "`uname -r | grep -- "-"`" ]; then
ktag="`cat /proc/version`"
...
fi
#
#
if [ $usb = "1" ]; then
sleep 5
mouseoutput=`cat /proc/bus/usb/devices 2>/dev/null|grep -E "^I.*Cls=03.*Prot=02"`
kbdoutput=`cat /proc/bus/usb/devices 2>/dev/null|grep -E "^I.*Cls=03.*Prot=01"`
...
fi
</source> 
Не используйте переменные для хранения содержимого текстовых файлов большого объёма, без веских на то оснований. Не записывайте в переменные содержимое бинарных файлов, даже шутки ради. 
 '''Пример''': '''''Глупая выходка.'''''
<source lang="bash">
#!/bin/bash
# stupid-script-tricks.sh: Люди! Будьте благоразумны!
# Из "Глупые выходки", том I.
dangerous_variable=`cat /boot/vmlinuz` # Сжатое ядро Linux.
echo "длина строки \$dangerous_variable = ${#dangerous_variable}"
# длина строки $dangerous_variable = 794151
# ('wc -c /boot/vmlinuz' даст другой результат.)
# echo "$dangerous_variable"
# Даже не пробуйте раскомментировать эту строку! Это приведёт к зависанию сценария.
# Автор этого документа не знает, где можно было бы использовать запись содержимого двоичных файлов в переменные.
exit 0
</source> 
Обратите внимание: в данной ситуации не возникает ошибки переполнения буфера. Этот пример показывает превосходство защищённости интерпретирующих языков, таких как Bash, от ошибок программиста, над компилирующими языками программирования. Подстановка команд, позволяет записать в переменную результаты выполнения цикла. Ключевым моментом здесь является команда '''''echo''''', в теле цикла.
 '''Пример''': '''''Запись результатов выполнения цикла в переменную.'''''
<source lang="bash">
#!/bin/bash
# csubloop.sh: Запись результатов выполнения цикла в переменную
variable1=`for i in 1 2 3 4 5
do
echo -n "$i" # Здесь 'echo' — это ключевой момент
done`
echo "variable1 = $variable1" # variable1 = 12345
i=0
variable2=`while [ "$i" -lt 10 ]
do
echo -n "$i" # Опять же, команда 'echo' просто необходима.
let "i += 1" # Увеличение на 1.
done`
echo "variable2 = $variable2" # variable2 = 0123456789
exit 0
</source> 
{| class="wikitable"
|-
| Подстановка команд позволяет существенно расширить набор инструментальных средств, которыми располагает Bash. Суть состоит в том, чтобы написать программу или сценарий, которая выводит результаты своей работы на ''stdout'' (как это делает подавляющее большинство утилит в Unix) и записать вывод от программы в переменную. 
<source lang="c">
#include <stdio.h>
/* Программа на C "Hello, world." */
int main()
{
printf( "Hello, world." );
return (0);
}
</source>
<source lang="bash">
bash$ gcc -o hello hello.c
#!/bin/bash
# hello.sh
greeting=`./hello`
echo $greeting
bash$ sh hello.sh
Hello, world.
</source> 
|} 
Альтернативой обратным одиночным кавычкам, используемым для подстановки команд, можно считать такую форму записи: '''''$(COMMAND)'''''.
<source lang="bash">
output=$(sed -n /"$1"/p $file) # К примеру из "grp.sh".

# Запись в переменную содержимого текстового файла.
File_contents1=$(cat $file1)
File_contents2=$(<$file2) # Bash допускает и такую запись.
</source> 
Следует упомянуть, что в конструкции '''''$(...)''''' два идущих подряд обратных слэша интерпретируются несколько иначе, чем в конструкции '''''`...`'''''.
<source lang="bash">
bash$ echo `echo \\`

bash$ echo $(echo \\)
\
</source> 

== Арифметические подстановки ==
Арифметические подстановки — это мощный инструмент, предназначенный для выполнения арифметических операций в сценариях. Перевод строки в числовое выражение производится с помощью обратных одиночных кавычек, двойных круглых скобок или предложения '''''let'''''.
'''Вариации''' 
Арифметические подстановки в обратных одиночных кавычках(часто используются совместно с командой '''''expr''''').
<source lang="bash">
z=`expr $z + 3` # Команда 'expr' вычисляет значение выражения.
</source> 
Арифметические подстановки в двойных круглых скобках и предложение '''''let'''''. 
В арифметических подстановках, обратные одиночные кавычки могут быть заменены на двойные круглые скобки — '''''$((...))''''' и '''''$((...))''''' или очень удобной конструкцией, с применением предложения '''''let'''''. 
<source lang="bash">
z=$(($z+3))
z=$((z+3) # Тоже верно.
# Внутри двойных круглых скобок, переменные разыменовываются автоматически.
# $((EXPRESSION)) — это подстановка арифметического выражения!
# Не путайте с подстановкой команд!
# Внутри двойных круглых скобок допускается выполнение арифметических
# действий без использования оператора присваивания
n=0
echo "n = $n" # n = 0
(( n += 1 )) # Инкремент.
# (( $n += 1 )) это неверно!
echo "n = $n" # n = 1
let z=z+3
let "z += 3" # Кавычки позволяют вставлять пробелы
# Оператор 'let' вычисляет арифметическое выражение,
# это не подстановка арифметического выражения.
</source> 

== Перенаправление ввода/вывода ==
В системе по-умолчанию всегда открыты три "файла" — ''stdin'' (клавиатура), ''stdout'' (экран) и ''stderr''(вывод сообщений об ошибках на экран). Эти, и любые другие открытые файлы, могут быть перенаправлены. В данном случае, термин "''перенаправление''" означает получить вывод из файла, команды, программы, сценария или даже отдельного блока в сценарии и передать его на вход в другой файл, команду, программу или сценарий. 
С каждым открытым файлом связан дескриптор файла. Дескрипторы файлов ''stdin'', ''stdout'' и ''stderr'' — 0, 1 и 2, соответственно. При открытии дополнительных файлов, дескрипторы с 3 по 9 остаются незанятыми. Иногда дополнительные дескрипторы могут сослужить неплохую службу, временно сохраняя в себе ссылку на ''stdin'', ''stdout'' или ''stderr''. Это упрощает возврат дескрипторов в нормальное состояние после сложных манипуляций с перенаправлением и перестановками.
<source lang="bash">
COMMAND_OUTPUT >
# Перенаправление stdout (вывода) в файл.
# Если файл отсутствовал, то он создаётся, иначе — перезаписывается.

ls -lR > dir-tree.list
# Создаёт файл, содержащий список дерева каталогов.
: > filename
# Операция > усекает файл "filename" до нулевой длины.
# Если до выполнения операции файла не существовало,
# то создаётся новый файл с нулевой длиной (тот же эффект дает команда 'touch').
# Символ : выступает здесь в роли местозаполнителя, не выводя ничего.
> filename
# Операция > усекает файл "filename" до нулевой длины.
# Если до выполнения операции файла не существовало,
# то создается новый файл с нулевой длиной (тот же эффект дает команда 'touch').
# (тот же результат, что и выше — ": >", но этот вариант неработоспособен
# в некоторых командных оболочках.)
COMMAND_OUTPUT >>
# Перенаправление stdout (вывода) в файл.
# Создаёт новый файл, если он отсутствовал, иначе — дописывает в конец файла.

# Однострочные команды перенаправления
# (затрагивают только ту строку, в которой они встречаются):
# --------------------------------------------------------------------
1>filename
# Перенаправление вывода (stdout) в файл "filename".
1>>filename
# Перенаправление вывода (stdout) в файл "filename", файл открывается в режиме добавления.
2>filename
# Перенаправление stderr в файл "filename".
2>>filename
# Перенаправление stderr в файл "filename", файл открывается в режиме добавления.
&>filename
# Перенаправление stdout и stderr в файл "filename".

#==============================================================================
# Перенаправление stdout, только для одной строки.
LOGFILE=script.log

echo "Эта строка будет записана в файл \"$LOGFILE\"." 1>$LOGFILE
echo "Эта строка будет добавлена в конец файла \"$LOGFILE\"." 1>>$LOGFILE
echo "Эта строка тоже будет добавлена в конец файла \"$LOGFILE\"." 1>>$LOGFILE
echo "Эта строка будет выведена на экран и не попадет в файл \"$LOGFILE\"."
# После каждой строки, сделанное перенаправление автоматически "сбрасывается".

# Перенаправление stderr, только для одной строки.
ERRORFILE=script.errors

bad_command1 2>$ERRORFILE # Сообщение об ошибке запишется в $ERRORFILE.
bad_command2 2>>$ERRORFILE # Сообщение об ошибке добавится в конец $ERRORFILE.
bad_command3 # Сообщение об ошибке будет выведено на stderr, и не попадет в $ERRORFILE.
# После каждой строки, сделанное перенаправление также автоматически "сбрасывается".
#==============================================================================

2>&1
# Перенаправляется stderr на stdout.
# Сообщения об ошибках передаются туда же, куда и стандартный вывод.

i>&j
# Перенаправляется файл с дескриптором i в j.
# Вывод в файл с дескриптором i передаётся в файл с дескриптором j.

>&j
# Перенаправляется файл с дескриптором 1 (stdout) в файл с дескриптором j.
# Вывод на stdout передаётся в файл с дескриптором j.

0< FILENAME
< FILENAME
# Ввод из файла.
# Парная команде ">", часто встречается в комбинации с ней.
#
# grep search-word <filename

[j]<>filename
# Файл "filename" открывается на чтение и запись, и связывается с дескриптором "j". 249
# Если "filename" отсутствует, то он создаётся.
# Если дескриптор "j" не указан, то, по-умолчанию, берётся дескриптор 0, stdin.
#
# Как одно из применений этого — запись в конкретную позицию в файле.
echo 1234567890 > File # Записать строку в файл "File".
exec 3<> File # Открыть "File" и связать с дескриптором 3.
read -n 4 <&3 # Прочитать 4 символа.
echo -n . >&3 # Записать символ точки.
exec 3>&- # Закрыть дескриптор 3.
cat File # ==> 1234.67890
# Произвольный доступ, да и только!

|
# Конвейер (канал).
# Универсальное средство для объединения команд в одну цепочку.
# Похоже на ">", но на самом деле — более обширная.
# Используется для объединения команд, сценариев, файлов и программ в одну цепочку (конвейер).
cat *.txt | sort | uniq > result-file
# Содержимое всех файлов .txt сортируется, удаляются повторяющиеся строки,
# результат сохраняется в файле "result-file".
</source> 
Операции перенаправления и/или конвейеры могут комбинироваться в одной командной строке.
<source lang="bash">
command < input-file > output-file
command1 | command2 | command3 > output-file
</source> 
Допускается перенаправление нескольких потоков в один файл.
<source lang="bash">
ls -yz >> command.log 2>&1
# Сообщение о неверной опции "yz" в команде "ls" будет записано в файл "command.log".
# Поскольку stderr перенаправлен в файл.

# Обратите внимание: следующая строка даст иной результат.
ls -yz 2>&1 >> command.log
# Сообщение об ошибке не попадет в файл.
# Если производится перенаправление обоих устройств, stdout и stderr, то порядок действий изменяется.
</source> 
'''Закрытие дескрипторов файлов''' 
<big>'''n<&-'''</big> 
:Закрыть дескриптор входного файла n. 
<big>'''0<&-,<&-'''</big> 
:Закрыть ''stdin''. 
<big>'''n>&-'''</big> 
:Закрыть дескриптор выходного файла n. 
<big>'''1>&-,>&-'''</big> 
:Закрыть ''stdout''. 

Дочерние процессы наследуют дескрипторы открытых файлов. По этой причине и работают конвейеры. Чтобы предотвратить наследование дескрипторов — закройте их перед запуском дочернего процесса.
<source lang="bash">
# В конвейер передается только stderr.
exec 3>&1 # Сохранить текущее "состояние" stdout.
ls -l 2>&1 >&3 3>&- | grep bad 3>&- # Закрыть дескр. 3 для 'grep' (но не для 'ls').
# ^^^^ ^^^^
exec 3>&- # Теперь закрыть его для оставшейся части сценария.
# Спасибо S.C.
</source> 
=== С помощью команды exec ===
Команда '''''exec <filename''''' перенаправляет ввод со ''stdin'' на файл. С этого момента весь ввод, вместо ''stdin'' (обычно это клавиатура), будет производиться из этого файла. Это даёт возможность читать содержимое файла, строку за строкой, и анализировать каждую введённую строку с помощью [[sed]] и/или [[awk]].
 '''Пример''': '''''Перенаправление stdin с помощью exec.'''''
<source lang="bash">
#!/bin/bash
# Перенаправление stdin с помощью 'exec'.
exec 6<&0 # Связать дескр. #6 со стандартным вводом (stdin).
# Сохраняя stdin.

exec < data-file # stdin заменяется файлом "data-file"

read a1 # Читается первая строка из "data-file".
read a2 # Читается вторая строка из "data-file."

echo
echo "Следующие строки были прочитаны из файла."
echo "-----------------------------------------"
echo $a1
echo $a2

echo; echo; echo

exec 0<&6 6<&-
# Восстанавливается stdin из дескр. #6, где он был предварительно сохранен,
# и дескр. #6 закрывается ( 6<&- ) освобождая его для других процессов.
#
#<&6 6<&- даёт тот же результат.

echo -n "Введите строку "
read b1 # Теперь функция "read", как и следовало ожидать, принимает данные с обычного stdin.
echo "Строка, принятая со stdin."
echo "--------------------------"
echo "b1 = $b1"

echo

exit 0
</source> 
Аналогично, конструкция '''''exec >filename''''' перенаправляет вывод на ''stdout'' в заданный файл. После этого, весь вывод от команд, который обычно направляется на ''stdout'', теперь выводится в этот файл.
 '''Пример''': '''''Перенаправление stdout с помощью exec.'''''
<source lang="bash">
#!/bin/bash
# reassign-stdout.sh
LOGFILE=logfile.txt
exec 6>&1 # Связать дескр. #6 со stdout.
# Сохраняя stdout.

exec > $LOGFILE # stdout замещается файлом "logfile.txt".
# ----------------------------------------------------------- #
# Весь вывод от команд, в данном блоке, записывается в файл $LOGFILE.

echo -n "Logfile: "
date
echo "-------------------------------------"
echo
echo "Вывод команды \"ls -al\""
echo
ls -al
echo; echo
echo "Вывод команды \"df\""
echo
df
# ----------------------------------------------------------- #
exec 1>&6 6>&- # Восстановить stdout и закрыть дескр. #6.
echo
echo "== stdout восстановлено в значение по-умолчанию == "
echo
ls -al
echo

exit 0
</source> 
 '''Пример''': '''''Одновременное перенаправление устройств, stdin и stdout, с помощью команды exec.'''''
<source lang="bash">
#!/bin/bash
# upperconv.sh
# Преобразование символов во входном файле в верхний регистр.
E_FILE_ACCESS=70
E_WRONG_ARGS=71
if [ ! -r "$1" ] # Файл доступен для чтения?
then
echo "Невозможно прочитать из заданного файла!"
echo "Порядок использования: $0 input-file output-file"
exit $E_FILE_ACCESS
fi # В случае, если входной файл ($1) не задан код завершения будет этим же.

if [ -z "$2" ]
then
echo "Необходимо задать выходной файл."
echo "Порядок использования: $0 input-file output-file"
exit $E_WRONG_ARGS
fi
exec 4<&0
exec < $1 # Назначить ввод из входного файла.
exec 7>&1
exec > $2 # Назначить вывод в выходной файл.
# Предполагается, что выходной файл доступен для записи (добавить проверку?).

# -----------------------------------------------
cat - | tr a-z A-Z # Перевод в верхний регистр
# ^^^^^ # Чтение со stdin.
# ^^^^^^^^^^ # Запись в stdout.
# Однако, и stdin и stdout были перенаправлены.
# -----------------------------------------------
exec 1>&7 7>&- # Восстановить stdout.
exec 0<&4 4<&- # Восстановить stdin.

# После восстановления, следующая строка выводится на stdout, чего и следовало ожидать.
echo "Символы из \"$1\" преобразованы в верхний регистр, результат записан в \"$2\"."

exit 0
</source> 
=== Перенаправление для блоков кода ===
Блоки кода, такие как циклы ''while'', ''until'' и ''for'', условный оператор ''if/then'', так же могут смешиваться с перенаправлением ''stdin''. Даже функции могут использовать эту форму перенаправления. Оператор перенаправления '''''<''''', в таких случаях, ставится в конце блока.
 '''Пример''': '''''Перенаправление в цикл while.'''''
<source lang="bash">
#!/bin/bash
if [ -z "$1" ]
then
Filename=names.data # По-умолчанию, если имя файла не задано.
else
Filename=$1
fi
# Конструкцию проверки выше, можно заменить следующей строкой (подстановка параметров):
# Filename=${1:-names.data}

count=0
echo
while [ "$name" != Smith ] # Почему переменная $name взята в кавычки?
do
read name # Чтение из $Filename, не со stdin.
echo $name
let "count += 1"
done <"$Filename" # Перенаправление на ввод из файла $Filename.
# ^^^^^^^^^^^^

echo; echo "Имён прочитано: $count"; echo
# Обратите внимание: в некоторых старых командных интерпретаторах,
# перенаправление в циклы приводит к запуску цикла в субоболочке (subshell).
# Таким образом, переменная $count, по окончании цикла, будет содержать 0,
# значение, записанное в неё до входа в цикл.
# Bash и ksh стремятся избежать запуска субоболочки (subshell), если это возможно,
# так что этот сценарий, в этих оболочках, работает корректно.
#
# Спасибо Heiner Steven за это примечание.
exit 0
</source> 
 '''Пример''': '''''Альтернативная форма перенаправления в цикле while.'''''
<source lang="bash">
#!/bin/bash
# Это альтернативный вариант предыдущего сценария.
# Предложил: by Heiner Steven
# для случаев, когда циклы с перенаправлением
# запускаются в субоболочке, из-за чего переменные, устанавливаемые в цикле,
# не сохраняют свои значения по завершении цикла.

if [ -z "$1" ]
then
Filename=names.data # По-умолчанию, если имя файла не задано.
else
Filename=$1
fi
exec 3<&0 # Сохранить stdin в дескр. 3.
exec 0<"$Filename" # Перенаправить stdin.

count=0
echo
while [ "$name" != Smith ]
do
read name # Прочитать с перенаправленного stdin ($Filename).
echo $name
let "count += 1"
done <"$Filename" # Цикл читает из файла $Filename.
# ^^^^^^^^^^^^

exec 0<&3 # Восстановить stdin.
exec 3<&- # Закрыть временный дескриптор 3.
echo; echo "Имен прочитано: $count"; echo

exit 0
</source> 
 '''Пример''': '''''Перенаправление в цикл until.'''''
<source lang="bash">
#!/bin/bash
# То же самое, что и в предыдущем примере, только для цикла "until".

if [ -z "$1" ]
then
Filename=names.data # По-умолчанию, если файл не задан.
else
Filename=$1
fi
# while [ "$name" != Smith ]
until [ "$name" = Smith ] # Проверка != изменена на =.
do
read name # Чтение из $Filename, не со stdin.
echo $name
done <"$Filename" # Перенаправление на ввод из файла $Filename.
# ^^^^^^^^^^^^

# Результаты получаются теми же, что и в случае с циклом "while", в предыдущем примере.
exit 0
</source> 
 '''Пример''': '''''Перенаправление в цикл for.'''''
<source lang="bash">
#!/bin/bash
if [ -z "$1" ]
then
Filename=names.data # По-умолчанию, если файл не задан.
else
Filename=$1
fi
line_count=`wc $Filename | awk '{ print $1 }'`
# Число строк в файле.
# Слишком запутано, тем не менее показывает
# возможность перенаправления stdin внутри цикла "for"...
# если вы достаточно умны.
# Более короткий вариант line_count=$(wc < "$Filename")

for name in `seq $line_count` # "seq" выводит последовательность чисел.
# while [ "$name" != Smith ] — более запутанно, чем в случае с циклом "while"
do
read name # Чтение из файла $Filename, не со stdin.
echo $name
if [ "$name" = Smith ]
then
break
fi
done <"$Filename" # Перенаправление на ввод из файла $Filename.
# ^^^^^^^^^^^^
exit 0
</source> 
Предыдущий пример можно модифицировать так, чтобы перенаправить вывод из цикла.
 '''Пример''': '''''Перенаправление устройств (stdin и stdout) в цикле for.'''''
<source lang="bash">
#!/bin/bash
if [ -z "$1" ]
then
Filename=names.data # По-умолчанию, если файл не задан.
else
Filename=$1
fi
Savefile=$Filename.new # Имя файла, в котором сохраняются результаты.
FinalName=Jonah # Имя, на котором завершается чтение.

line_count=`wc $Filename | awk '{ print $1 }'` # Число строк в заданном файле.

for name in `seq $line_count`
do
read name
echo "$name"
if [ "$name" = "$FinalName" ]
then
break
fi
done < "$Filename" > "$Savefile" # Перенаправление на ввод из файла $Filename,
# ^^^^^^^^^^^^^^^^^^^^^^^^^^^ и сохранение результатов в файле.
exit 0
</source> 
 '''Пример''': '''''Перенаправление в конструкции if/then.'''''
<source lang="bash">
#!/bin/bash
if [ -z "$1" ]
then
Filename=names.data # По-умолчанию, если файл не задан.
else
Filename=$1
fi
TRUE=1
if [ "$TRUE" ] # конструкции "if true" и "if :" тоже вполне допустимы.
then
read name
echo $name
fi <"$Filename"
# ^^^^^^^^^^^^
# Читает только первую строку из файла.
exit 0
</source> 
 '''Пример''': '''''Файл с именами "names.data", для примеров выше.'''''
<source lang="bash">
Aristotle
Belisarius
Capablanca
Euler
Goethe
Hamurabi
Jonah
Laplace
Maroczy
Purcell
Schmidt
Semmelweiss
Smith
Turing
Venn
Wilson
Znosko-Borowski
# Это файл с именами для примеров
# "redir2.sh", "redir3.sh", "redir4.sh", "redir4a.sh", "redir5.sh".
</source> 
Перенаправление ''stdout'' для блока кода, может использоваться для сохранения результатов работы этого блока в файл. 
Встроенный документ — это особая форма перенаправления для блоков кода.
=== Область применения ===
Как один из вариантов грамотного применения перенаправления ввода/вывода, можно назвать разбор и "сшивание" вывода от команд. Это позволяет создавать файлы отчетов и журналов регистрации событий.
 '''Пример''': '''''Регистрация событий.'''''
<source lang="bash">
#!/bin/bash
# logevents.sh, автор: Stephane Chazelas.
# Регистрация событий в файле.
# Сценарий должен запускаться с привилегиями root (что бы иметь право на запись в /var/log).

ROOT_UID=0 # Привилегии root имеет только пользователь с $UID = 0.
E_NOTROOT=67 # Код завершения, если не root.

if [ "$UID" -ne "$ROOT_UID" ]
then
echo "Сценарий должен запускаться с привилегиями root."
exit $E_NOTROOT
fi
FD_DEBUG1=3
FD_DEBUG2=4
FD_DEBUG3=5

# Раскомментируйте одну из двух строк, ниже, для активизации сценария.
# LOG_EVENTS=1
# LOG_VARS=1log() # Запись даты и времени в файл.

log() # Запись даты и времени в файл.
{
echo "$(date) $*" >&7 # Добавляет в конец файла.
}

case $LOG_LEVEL in
1) exec 3>&2 4> /dev/null 5> /dev/null;;
2) exec 3>&2 4>&2 5> /dev/null;;
3) exec 3>&2 4>&2 5>&2;;
*) exec 3> /dev/null 4> /dev/null 5> /dev/null;;
esac
FD_LOGVARS=6
if [[ $LOG_VARS ]]
then exec 6>> /var/log/vars.log
else exec 6> /dev/null # Подавить вывод.
fi

FD_LOGEVENTS=7
if [[ $LOG_EVENTS ]]
then
# then exec 7 >(exec gawk '{print strftime(), $0}' >> /var/log/event.log)
# Строка, выше, не работает в Bash, версии 2.04.
exec 7>> /var/log/event.log # Добавление в конец "event.log".
log # Записать дату и время.
else exec 7> /dev/null # Подавить вывод.
fi
echo "DEBUG3: beginning" >&${FD_DEBUG3}
ls -l >&5 2>&4 # command1 >&5 2>&4
echo "Done" # command2
echo "sending mail" >&${FD_LOGEVENTS} # Написать "sending mail" в дескр. #7.

exit 0
</source> 

== Встроенные документы ==
''Встроенный документ'' (here document) является специальной формой перенаправления ввода/вывода, которая позволяет передать список команд интерактивной программе или команде, например '''''ftp''''', '''''telnet''''' или '''''ex'''''.
<source lang="bash">
COMMAND <<InputComesFromHERE
...
InputComesFromHERE
</source> 
Конец встроенного документа выделяется "строкой-ограничителем", которая задается с помощью специальной последовательности символов <<. Эта последовательность — есть перенаправление вывода из файла на ''stdin'' программы или команды, что напоминает конструкцию '''''interactive-program< command-file''''', где ''command-file'' содержит строки:
<source lang="bash">
command #1
command #2
...
</source> 
Сценарий, использующий "встроенный документ" для тех же целей, может выглядеть примерно так:
<source lang="bash">
#!/bin/bash
interactive-program <<LimitString
command #1
command #2
...
LimitString
</source> 
В качестве строки-ограничителя должна выбираться такая последовательность символов, которая не будет встречаться в теле "встроенного документа". 
Обратите внимание: использование встроенных документов может иногда с успехом применяться и при работе с неинтерактивными командами и утилитами.
 '''Пример''': '''''dummyfile: Создание 2-х строчного файла-заготовки.'''''
<source lang="bash">
#!/bin/bash
# Неинтерактивное редактирование файла с помощью 'vi'.
# Эмуляция 'sed'.
E_BADARGS=65

if [ -z "$1" ]
then
echo "Порядок использования: `basename $0` filename"
exit $E_BADARGS
fi

TARGETFILE=$1
# Вставить 2 строки в файл и сохранить.
#--------Начало встроенного документа-----------#
vi $TARGETFILE <<x23LimitStringx23
i
Это строка 1.
Это строка 2.
^[
ZZ
x23LimitStringx23
#----------Конец встроенного документа-----------#
# Обратите внимание: ^[, выше — это escape-символ Control-V <Esc>.

# Bram Moolenaar указывает, что этот скрипт может не работать с 'vim',
# из-за возможных проблем взаимодействия с терминалом.
exit 0
</source> 
Этот сценарий, с тем же эффектом, мог бы быть реализован, основываясь не на '''''vi''''', а на '''''ex'''''. Встроенные документы, содержащие команды для '''''ex''''', стали настолько обычным делом, что их уже смело можно вынести в отдельную категорию — ''ex-сценарии''.
 '''Пример''': '''''broadcast: Передача сообщения всем, работающим в системе,пользователям.'''''
<source lang="bash">
#!/bin/bash
wall <<zzz23EndOfMessagezzz23
Пошлите, по электронной почте, ваш заказ на пиццу, системному администратору.
(Добавьте дополнительный доллар, если вы желаете положить на пиццу анчоусы или грибы.)
# Внимание: строки комментария тоже будут переданы команде 'wall' как часть текста.
zzz23EndOfMessagezzz23

# Возможно, более эффективно это может быть сделано так:
# wall <message-file
# Однако, встроенный документ помогает сэкономить ваши силы и время.
exit 0
</source> 
 '''Пример''': '''''Вывод многострочных сообщений с помощью cat.'''''
<source lang="bash">
#!/bin/bash
# Команда 'echo' прекрасно справляется с выводом однострочных сообщений,
# но иногда необходимо вывести несколько строк.
# Команда 'cat' и встроенный документ помогут вам в этом.
cat <<End-of-message
-------------------------------------
Это первая строка сообщения.
Это вторая строка сообщения.
Это третья строка сообщения.
Это четвертая строка сообщения.
Это последняя строка сообщения.
-------------------------------------
End-of-message
exit 0
#--------------------------------------------
# Команда "exit 0", выше, не позволить исполнить нижележащие строки.
# S.C. отмечает, что следующий код работает точно так же.
echo "-------------------------------------
Это первая строка сообщения.
Это вторая строка сообщения.
Это третья строка сообщения.
Это четвертая строка сообщения.
Это последняя строка сообщения.
-------------------------------------"
# Однако, в этом случае, двойные кавычки в теле сообщения, должны экранироваться.
</source> 
Если строка-ограничитель встроенного документа начинается с символа '''-''' (<<-LimitString), то это приводит к подавлению вывода ведущих (начальных) символов табуляции (но не пробелов). Это может оказаться полезным при форматировании текста сценария для большей удобочитаемости. 
 '''Пример''': '''''Вывод многострочных сообщений с подавлением символов табуляции.'''''
<source lang="bash">
#!/bin/bash
# То же, что и предыдущий сценарий, но...
# Символ "-", начинающий строку-ограничитель встроенного документа: <<-
# подавляет вывод символов табуляции, которые могут встречаться в теле документа,
# но не пробелов.

cat <<-ENDOFMESSAGE
Это первая строка сообщения.
Это вторая строка сообщения.
Это третья строка сообщения.
Это четвертая строка сообщения.
Это последняя строка сообщения.
ENDOFMESSAGE
# Текст, выводимый сценарием, будет смещен влево.
# Ведущие символы табуляции не будут выводиться.

# Вышеприведённые 5 строк текста "сообщения" начинаются с табуляции, а не с пробелов.
exit 0
</source> 
Встроенные документы поддерживают подстановку команд и параметров. Что позволяет передавать различные параметры в тело встроенного документа. 
 '''Пример''': '''''Встроенные документы и подстановка параметров.'''''
<source lang="bash">
#!/bin/bash
# Вывод встроенного документа командой 'cat', с использованием подстановки параметров.
# Попробуйте запустить сценарий без аргументов, ./scriptname
# Попробуйте запустить сценарий с одним аргументом, ./scriptname Mortimer
# Попробуйте запустить сценарий с одним аргументом, из двух слов, в кавычках,
# ./scriptname "Mortimer Jones"

CMDLINEPARAM=1 # Минимальное число аргументов командной строки.

if [ $# -ge $CMDLINEPARAM ]
then
NAME=$1 # Если аргументов больше одного,
# то рассматривается только первый.
else
NAME="John Doe" # По-умолчанию, если сценарий запущен без аргументов.
fi
RESPONDENT="автора этого сценария"

cat <<Endofmessage
Привет, $NAME!
Примите поздравления от $RESPONDENT.
# Этот комментарий тоже выводится (почему?).
Endofmessage
# Обратите внимание на то, что пустые строки тоже выводятся.

exit 0
</source> 
Ещё один пример сценария, содержащего встроенный документ и подстановку параметров в его теле. 
 '''Пример''': '''''Передача пары файлов во входящий каталог на "Sunsite".'''''
<source lang="bash">
#!/bin/bash
# upload.sh
# Передача пары файлов (Filename.lsm, Filename.tar.gz)
# на Sunsite (ibiblio.org).

E_ARGERROR=65
if [ -z "$1" ]
then
echo "Порядок использования: `basename $0` filename"
exit $E_ARGERROR
fi

Filename=`basename $1` # Отсечь имя файла от пути к нему.
Server="ibiblio.org"
Directory="/incoming/Linux"
# Вообще, эти строки должны бы не "зашиваться" жёстко в сценарий,
# а приниматься в виде аргумента из командной строки.

Password="your.e-mail.address" # Измените на свой.
ftp -n $Server <<End-Of-Session
# Ключ -n запрещает автоматическую регистрацию (auto-logon)

user anonymous "$Password"
binary
bell # "Звякнуть" после передачи каждого файла
cd $Directory
put "$Filename.lsm"
put "$Filename.tar.gz"
bye
End-Of-Session
exit 0
</source> 
Заключая строку-ограничитель в кавычки или экранируя её, можно запретить подстановку параметров в теле встроенного документа. 
 '''Пример''': '''''Отключение подстановки параметров.'''''
<source lang="bash">
#!/bin/bash
# Вывод встроенного документа командой 'cat', с запретом подстановки параметров.

NAME="John Doe"
RESPONDENT="автора этого сценария"

cat <<'Endofmessage'

Привет, $NAME.
Примите поздравления от $RESPONDENT.
Endofmessage
# Подстановка параметров не производится, если строка ограничитель заключена в кавычки или экранирована.
# Тот же эффект дают:
# cat <<"Endofmessage"
# cat <<\Endofmessage
exit 0
</source> 
Запрет на подстановку параметров позволяет выводить текст, как говорится, "один к одному". Это обстоятельство может использоваться, например, для автоматической генерации сценариев или даже текстов программ на других языках программирования. 
 '''Пример''': '''''Сценарий, который создаёт другой сценарий.'''''
<source lang="bash">
#!/bin/bash
# generate-script.sh
# Автор идеи: Albert Reiner.
OUTFILE=generated.sh # Имя нового сценария.

# -----------------------------------------------------------
# 'Встроенный документ' содержит тело создаваемого сценария.
(
cat <<'EOF'
#!/bin/bash

echo "Этот сценарий сгенерирован автоматически."
# Обратите внимание: поскольку действия происходят в подоболочке,
# мы не можем получить доступ к переменным родительской оболочки.
# Удостоверимся в этом...
echo "Файл сценария был назван: $OUTFILE" # Не работает.
a=7
b=3
let "c = $a * $b"
echo "c = $c"
exit 0
EOF
) > $OUTFILE
# -----------------------------------------------------------

# Заключение 'строки-ограничителя' предотвращает подстановку значений переменных в теле 'встроенного документа.'
# Что позволяет записать все строки в выходной файл "один к одному".

if [ -f "$OUTFILE" ]
then
chmod 755 $OUTFILE
# Дать право на исполнение.
else
echo "Не могу создать файл: \"$OUTFILE\""
fi
# Этот метод можно использовать для создания Makefile-ов, программ на языках C, Perl, Python и т.п.

exit 0
</source> 
Допускается запись тела встроенного документа в переменную. 
<source lang="bash">
variable=$(cat <<SETVAR
Это многострочная переменная.
SETVAR)
echo "$variable"
</source> 
Встроенные документы могут передаваться на вход функции, находящейся в том же сценарии. 
 '''Пример''': '''''Встроенные документы и функции.'''''
<source lang="bash">
#!/bin/bash
# here-function.sh
GetPersonalData ()
{
read firstname
read lastname
read address
read city
read state
read zipcode
} # Это немного напоминает интерактивную функцию, но...

# Передать ввод в функцию.
GetPersonalData <<RECORD001
Bozo
Bozeman
2726
Nondescript Dr.
Baltimore
MD
21226
RECORD001

echo
echo "$firstname $lastname"
echo "$address"
echo "$city, $state $zipcode"
echo
exit 0
</source> 
Встроенный документ можно передать "пустой команде" :. Такая конструкция, фактически, создаёт "анонимный" встроенный документ. 
 '''Пример''': '''''"Анонимный" встроенный документ.'''''
<source lang="bash">
#!/bin/bash
: <<TESTVARIABLES${HOSTNAME?}${USER?}${MAIL?} # Если одна из переменных не определена, то выводится сообщение об ошибке.
TESTVARIABLES
exit 0
</source> 
Подобную технику можно использовать для создания "блочных комментариев". 
 '''Пример''': '''''Блочный комментарий.'''''
<source lang="bash">
#!/bin/bash
# commentblock.sh
: << COMMENTBLOCK
echo "Эта строка не будет выведена."
Эта строка комментария не начинается с символа "#".
Это ещё одна строка комментария, которая начинается не с символа "#".

&*@!!++=
Эта строка не вызовет ошибки,
поскольку Bash проигнорирует её.
COMMENTBLOCK
echo "Код завершения \"COMMENTBLOCK\" = $?." # 0
# Показывает, что ошибок не возникало.

# Такая методика создания блочных комментариев может использоваться для комментирования блоков кода во время отладки.
# Это экономит силы и время, т.к. не нужно вставлять символ "#" в начале каждой строки, а затем удалять их.

: << DEBUGXXX
for file in *
do
cat "$file"
done
DEBUGXXX

exit 0
</source> 
Ещё одно остроумное применение встроенных документов — встроенная справка к сценарию. 
 '''Пример''': '''''Встроенная справка к сценарию.'''''
<source lang="bash">
#!/bin/bash
# self-document.sh: сценарий со встроенной справкой
# Модификация сценария "colm.sh".

DOC_REQUEST=70
if [ "$1" = "-h" -o "$1" = "--help" ] # Request help.
then
echo; echo "Порядок использования: $0 [directory-name]"; echo
sed --silent -e '/DOCUMENTATIONXX$/,/^DOCUMENTATION/p' "$0" |
sed -e '/DOCUMENTATIONXX/d'; exit $DOC_REQUEST; fi
: << DOCUMENTATIONXX
Сценарий выводит сведения о заданном каталоге в виде таблице.
-------------------------------------------------------------
Сценарию необходимо передать имя каталога. Если каталог неуказан или он недоступен для чтения, то выводятся сведения о текущем каталоге.
DOCUMENTATIONXX
if [ -z "$1" -o ! -r "$1" ]
then
directory=.
else
directory="$1"
fi
echo "Сведения о каталоге "$directory":"; echo
(printf "PERMISSIONS LINKS OWNER GROUP SIZE MONTH DAY HH:MM PROG-NAME\n" \
; ls -l "$directory" | sed 1d) | column -t
exit 0
</source> 
Для встроенных документов, во время исполнения, создаются временные файлы, но эти файлыудаляются после открытия и недоступны для других процессов. 
<source lang="bash">
bash$ bash -c 'lsof -a -p $$ -d0' << EOF
> EOF
lsof 1213 bozo 0r REG 3,5 0 30386 /tmp/t1213-0-sh (deleted)
</source> 
Некоторые утилиты не могут работать внутри встроенных документов. Строка-ограничитель, закрывающая встроенный документ, должна начинаться с первого символа в строке. Перед ней не должно быть пробельных символов. Аналогично, пробельные символы, стоящие за строкой-ограничителем, могут дать нежелательные побочные эффекты. 
<source lang="bash">
#!/bin/bash
echo "----------------------------------------------------------------------"
cat <<LimitString
echo "Это первая строка сообщения во встроенном документе."
echo "Это вторая строка сообщения во встроенном документе."
echo "Это последняя строка сообщения во встроенном документе."
LimitString
#^^^^Отступ перед строкой-ограничителем. Ошибка!
# Этот сценарий будет вести себя не так как вы ожидаете.

echo "----------------------------------------------------------------------"
# "Этот комментарий находится за пределами 'встроенного документа', и не должен выводиться.
echo "За пределами встроенного документа."

exit 0

echo "Держу пари, что эта строка не будет выведена." # Стоит после команды 'exit'.
</source> 
Если какая-либо задача не может быть решена с помощью "встроенного документа", то вам следует попробовать язык сценариев '''''expect''''', который приспособлен для передачи параметров на вход интерактивных программ.

= Часть четвёртая. Материал повышенной сложности =
Итак, мы вплотную подошли к изучению очень сложных и необычных аспектов написания сценариев. В этой части мы попытаемся "'''сбросить покров тайны'''" и заглянуть за пределы известного нам мира(представьте себе путешествие по территории, не отмеченной на карте).
== Регулярные выражения ==
Для того, чтобы полностью реализовать потенциал командной оболочки, вам придётся овладеть ''Регулярными Выражениями''. Многие команды и утилиты, обычно используемые в сценариях, такие как [[grep]], [[expr]], [[sed]] и [[awk]], используют ''Регулярные Выражения''.
=== Краткое введение в регулярные выражения ===
Выражение — это строка символов. Символы, которые имеют особое назначение, называются '''''метасимволами'''''. Так, например, кавычки могут выделять прямую речь, т.е. быть метасимволами для строки, заключенной в эти кавычки. '''''Регулярные выражения''''' — это набор символов и/или метасимволов, которые наделены особыми свойствами. 
Основное назначение регулярных выражений — это поиск текста по шаблону и работа со строками. 
* Звёздочка — <big>'''''*'''''</big> — означает любое количество символов в строке, предшествующих "звёздочке", в том числе и нулевое число символов.
:Выражение ''"113*"'' — означает ''11 + один или более символов "3" + любые другие символы: 113,1133, 113312'', и так далее.
* Точка —<big>''''' . '''''</big> — означает не менее одного любого символа, за исключением символа перевода строки — '''\n'''.
:Выражение "''13.''" будет означать ''13 + по меньшей мере один любой символ (включая пробел): 1133,11333 и т.д.'', но не ''13'' (отсутствуют дополнительные символы).
* Символ —'''''<big> ^ </big>'''''— означает начало строки, но иногда, в зависимости от контекста, означает отрицание в регулярных выражениях.
* Знак доллара —'''''<big> $ </big>'''''— в конце регулярного выражения соответствует концу строки.
:Выражение "'''''^$'''''" соответствует пустой строке.
* Квадратные скобки —'''''<big> [...] </big>''''' — предназначены для задания подмножества символов. Квадратные скобки, внутри регулярного выражения, считаются одним символом, который может принимать значения, перечисленные внутри этих скобок.
:Выражение "'''''[xyz]'''''" — соответствует одному из символов '''x''', '''y''' или '''z'''.
:Выражение "'''''[c-n]'''''" соответствует одному из символов в диапазоне от '''c''' до '''n''', включительно.
:Выражение "'''''[B-Pk-y]'''''" соответствует одному из символов в диапазоне от '''B''' до '''P''' или в диапазоне от '''k''' до '''y''', включительно.
:Выражение "'''''[a-z0-9]'''''" соответствует одному из символов латиницы в нижнем регистре или цифре. 
:Выражение "'''''[^b-d]'''''" соответствует любому символу, кроме символов из диапазона от '''b''' до '''d''', включительно. В данном случае, метасимвол '''^''' означает отрицание.
Объединяя квадратные скобки в одну последовательность, можно задать шаблон искомого слова.
:Так, выражение "'''''[Yy][Ee][Ss]'''''" соответствует словам '''yes''', '''Yes''', '''YES''', '''yEs''' и так далее.
:Выражение "'''''[0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9][0-9][0-9]'''''" определяет шаблон для поиска любого номера карточки социального страхования (для США).
* Обратный слэш —'''''<big> \ </big>''''' — служит для экранирования специальных символов, это означает, что экранированные символы должны интерпретироваться буквально, т.е. как простые символы.
:Комбинация "'''''\$'''''" указывает на то, что символ "'''$'''" трактуется как обычный символ, а не как признак конца строки в регулярных выражениях. Аналогично, комбинация "'''''\\'''''" соответствует простому символу "'''\'''".
* Экранированные "угловые скобки" —'''''<big> \<...\> </big>''''' — отмечают границы слова.
:Угловые скобки должны экранироваться, иначе они будут интерпретироваться как простые символы.
:Выражение "'''''\<the\>'''''" соответствует слову "'''the'''", и не соответствует словам "'''them'''", "'''there'''", "'''other'''" и т.п.
<source lang="bash">
bash$ cat textfile
This is line 1, of which there is only one instance.
This is the only instance of line 2.
This is line 3, another line.
This is line 4.

bash$ grep 'the' textfile
This is line 1, of which there is only one instance.
This is the only instance of line 2.
This is line 3, another line.

bash$ grep '\<the\>' textfile
This is the only instance of line 2.
</source> 
'''Дополнительные метасимволы'''. Использующиеся при работе с [[egrep]], [[awk]] и '''Perl'''
* Знак вопроса —'''''<big> ? </big>''''' — означает, что предыдущий символ или регулярное выражение встречается 0 или 1 раз. В основном используется для поиска одиночных символов.
* Знак "плюс" —'''''<big> + </big>''''' — указывает на то, что предыдущий символ или выражение встречается 1 или более раз. Играет ту же роль, что и символ "звёздочка" ('''*'''), за исключением случая нулевого количества вхождений.
<source lang="bash">
# GNU версии sed и awk допускают использование "+", но его необходимо экранировать.

echo a111b | sed -ne '/a1\+b/p'
echo a111b | grep 'a1\+b'
echo a111b | gawk '/a1+b/'
# Все три варианта эквивалентны.
# Спасибо S.C.
</source> 
* Экранированные "фигурные скобки" —'''''<big> \{ \} </big>''''' — задают число вхождений предыдущего выражения.
:Экранирование фигурных скобок — обязательное условие, иначе они будут интерпретироваться как простые символы. Такой порядок использования, технически, не является частью основного набора правил построения регулярных выражений.
:Выражение "'''''[0-9]\{5\}'''''" — в точности соответствует подстроке из пяти десятичных цифр(символов из диапазона от '''0''' до '''9''', включительно).
В "классической" (не совместимой с POSIX) версии [[awk]], фигурные скобки не могут быть использованы. Однако, в [[gawk]] предусмотрен ключ ''--re-interval'', который позволяет использовать (неэкранированные) фигурные скобки.
<source lang="bash">
bash$ echo 2222 | gawk --re-interval '/2{3}/'
2222
</source> 
Язык программирования '''Perl''' и некоторые версии [[egrep]] не требуют экранирования фигурных скобок.
* Круглые скобки —'''''<big> ( ) </big>''''' — предназначены для выделения групп регулярных выражений. Они полезны при использовании с оператором "'''|'''" и при извлечении подстроки с помощью команды '''''expr'''''.
* Вертикальная черта —'''''<big> | </big>''''' — выполняет роль логического оператора "ИЛИ" в регулярных выражениях и служит для задания набора альтернатив.
<source lang="bash">
bash$ egrep 're(a|e)d' misc.txt
People who read seem to be better informed than those who do not.
The clarinet produces sound by the vibration of its reed.
</source> 
Некоторые версии [[sed]], '''''ed''''' и '''''ex''''' поддерживают экранированные версии регулярных выражений, описанные выше.

'''Классы символов POSIX'''. [:class:] 
Это ''альтернативный способ'' указания диапазона символов.
* Класс '''''<big>[:alnum:]</big>''''' — соответствует алфавитным символам и цифрам. Эквивалентно выражению '''''A-Za-z0-9'''''.
* Класс '''''<big>[:alpha:]</big>''''' — соответствует символам алфавита. Эквивалентно выражению '''''A-Za-z'''''.
* Класс '''''<big>[:blank:]</big>''''' — соответствует символу пробела или символу табуляции.
* Класс '''''<big>[:cntrl:]</big>''''' — соответствует управляющим символам (control characters).
* Класс '''''<big>[:digit:]</big>''''' — соответствует набору десятичных цифр. Эквивалентно выражению 0-9.
* Класс '''''<big>[:graph:]</big>''''' — (печатаемые и псевдографические символы) — соответствует набору символов из диапазона ''ASCII 33'' - 126. Это то же самое, что и класс '''''[:print:]''''', за исключением символа пробела.
* Класс '''''<big>[:lower:]</big>''''' — соответствует набору алфавитных символов в нижнем регистре.Эквивалентно выражению '''a-z'''.
* Класс '''''<big>[:print:]</big>''''' — (печатаемые символы) — соответствует набору символов из диапазона ''ASCII 32'' - 126. По своему составу этот класс идентичен классу '''''[:graph:]''''', описанному выше, за исключением того, что в этом классе дополнительно присутствует символ пробела.
* Класс '''''<big>[:space:]</big>''''' — соответствует пробельным символам (пробел и горизонтальная табуляция).
* Класс '''''<big>[:upper:]</big>''''' — соответствует набору символов алфавита в верхнем регистре. Эквивалентно выражению '''A-Z'''.
* Класс '''''<big>[:xdigit:]</big>''''' — соответствует набору шестнадцатиричных цифр. Эквивалентно выражению '''0-9A-Fa-f'''.
Вообще, символьные классы POSIX требуют заключения в кавычки или двойные квадратные скобки ('''''[[ ]]''''').
<source lang="bash">
bash$ grep [[:digit:]] test.file
abc=723
</source> 
Эти символьные классы могут использоваться, с некоторыми ограничениями, даже в операциях подстановки имен файлов (''globbing'').
<source lang="bash">
bash$ ls -l ?[[:digit:]][[:digit:]]?
-rw-rw-r-- 1 bozo bozo 0 Aug 21 14:47 a33b
</source> 
[[Sed]], [[awk]] и [[Perl]], используемые в сценариях в качестве фильтров, могут принимать регулярные выражения в качестве входных аргументов. 
В качестве стандартного руководства по этой сложной теме можно порекомендовать "MasteringRegular Expressions", автор Friedl. Книга "'''''Sed & Awk'''''" (авторы ''Dougherty и Robbins'') так же даёт полное и ясное описание регулярных выражений (см. раздел Библиография).
=== Globbing — Подстановка имён файлов ===
Bash, сам по себе, не распознаёт регулярные выражения. Но в сценариях можно использовать команды и утилиты, такие как [[sed]] и [[awk]], которые прекрасно справляются с обработкой регулярных выражений. 
Фактически, Bash может выполнять подстановку имён файлов, этот процесс называется "''globbing''", но при этом не используется стандартный набор регулярных выражений. Вместо этого, при выполнении подстановки имён файлов, производится распознавание и интерпретация шаблонных символов. В число интерпретируемых шаблонов входят символы '''*''' и '''?''', списки символов в квадратных скобках и некоторые специальные символы (например '''^''', используемый для выполнения операции отрицания). Применение шаблонных символов имеет ряд важных ограничений. Например, если имена файлов начинаются с точки (например так: '''''.bashrc'''''), то они не будут соответствовать шаблону, содержащему символ '''*'''. Аналогично, символ '''?''' в операции подстановки имён файлов имеет иной смысл, нежели в регулярных выражениях.
<source lang="bash">
bash$ ls -l
total 2
-rw-rw-r-- 1 bozo bozo 0 Aug 6 18:42 a.1
-rw-rw-r-- 1 bozo bozo 0 Aug 6 18:42 b.1
-rw-rw-r-- 1 bozo bozo 0 Aug 6 18:42 c.1
-rw-rw-r-- 1 bozo bozo 466 Aug 6 17:48 t2.sh
-rw-rw-r-- 1 bozo bozo 758 Jul 30 09:02 test1.txt

bash$ ls -l t?.sh
-rw-rw-r-- 1 bozo bozo 466 Aug 6 17:48 t2.sh

bash$ ls -l [ab]*
-rw-rw-r-- 1 bozo bozo 0 Aug 6 18:42 a.1
-rw-rw-r-- 1 bozo bozo 0 Aug 6 18:42 b.1

bash$ ls -l [a-c]*
-rw-rw-r-- 1 bozo bozo 0 Aug 6 18:42 a.1
-rw-rw-r-- 1 bozo bozo 0 Aug 6 18:42 b.1
-rw-rw-r-- 1 bozo bozo 0 Aug 6 18:42 c.1

bash$ ls -l [^ab]*
-rw-rw-r-- 1 bozo bozo 0 Aug 6 18:42 c.1
-rw-rw-r-- 1 bozo bozo 466 Aug 6 17:48 t2.sh
-rw-rw-r-- 1 bozo bozo 758 Jul 30 09:02 test1.txt

bash$ ls -l {b*,c*,*est*}
-rw-rw-r-- 1 bozo bozo 0 Aug 6 18:42 b.1
-rw-rw-r-- 1 bozo bozo 0 Aug 6 18:42 c.1
-rw-rw-r-- 1 bozo bozo 758 Jul 30 09:02 test1.txt
</source> 
Bash выполняет подстановку имён файлов при использовании аргументов командной строки без кавычек. Команда [[echo]] наглядно демонстрирует это.
<source lang="bash">
bash$ echo *
a.1 b.1 c.1 t2.sh test1.txt

bash$ echo t*
t2.sh test1.txt
</source> 
Bash предоставляет возможность изменить порядок интерпретации специальных символов вовремя подстановки имён файлов. Так команда '''''set -f''''' запрещает подстановку, а ключи ''nocaseglob'' и ''nullglob'' в '''''shopt''''' изменяют характер подстановки.

== Подоболочки или Subshells ==
Запуск сценария приводит к запуску дочернего командного интерпретатора. Который выполняет интерпретацию и исполнение списка команд, содержащихся в файле сценария, точно так же, как если бы они были введены из командной строки. Любой сценарий запускается как дочерний процесс родительской командной оболочки, той самой, которая выводит перед вами строку приглашения к вводу на консоли или в окне '''''xterm'''''. Сценарий может, так же, запустить другой дочерний процесс, в своей подоболочке. Это позволяет сценариям распараллелить процесс обработки данных по нескольким задачам, исполняемым одновременно.
{| class="wikitable"
|-
|Как правило, внешние команды в сценариях порождают дочерние процессы, в то время как встроенные команды Bash — нет. По этой причине, встроенные команды выполняются много быстрее своих "внешних" аналогов.
|} 
'''Список команд в круглых скобках'''
:( command1; command2; command3; ... )
Список команд, в круглых скобках, исполняется в подоболочке. Значения переменных, определённых в дочерней оболочке, не могут быть переданы родительской оболочке. Они недоступны родительскому процессу. Фактически, они ведут себя как ''локальные переменные''.
 '''Пример''': '''''Область видимости переменных.'''''
<source lang="bash">
#!/bin/bash
# subshell.sh
echo
outer_variable=Outer

(
inner_variable=Inner
echo "Дочерний процесс, \"inner_variable\" = $inner_variable"
echo "Дочерний процесс, \"outer\" = $outer_variable"
)

echo

if [ -z "$inner_variable" ]
then
echo "Переменная inner_variable не определена в родительской оболочке"
else
echo "Переменная inner_variable определена в родительской оболочке"
fi

echo "Родительский процесс, \"inner_variable\" = $inner_variable"
# Переменная $inner_variable не будет определена
# потому, что переменные, определенные в дочернем процессе,
# ведут себя как "локальные переменные".

echo

exit 0
</source> 
+ 
Смена текущего каталога в дочернем процессе (подоболочке) не влечёт за собой смену текущего каталога в родительской оболочке.
 '''Пример''': '''''Личные настройки пользователей.'''''
<source lang="bash">
#!/bin/bash
# allprofs.sh: вывод личных настроек (profiles) всех пользователей
# Автор: Heiner Steven
# С некоторыми изменениями, внесенными автором документа.

FILE=.bashrc # Файл настроек пользователя,
# в оригинальном сценарии называется ".profile".

for home in `awk -F: '{print $6}' /etc/passwd`
do
[ -d "$home" ] || continue # Перейти к следующей итерации, если нет домашнего каталога.
[ -r "$home" ] || continue # Перейти к следующей итерации, если не доступен для чтения.
(cd $home; [ -e $FILE ] && less $FILE)
done
# По завершении сценария — нет необходимости выполнять команду 'cd', чтобы вернуться в первоначальный каталог, поскольку 'cd $home' выполняется в подоболочке.

exit 0
</source> 
Подоболочка может использоваться для задания "специфического окружения" для группы команд.
<source lang="bash">
COMMAND1
COMMAND2
COMMAND3
(
IFS=:
PATH=/bin
unset TERMINFO
set -C
shift 5
COMMAND4
COMMAND5
exit 3 # Выход только из подоболочки.
)
# Изменение переменных окружения не коснется родительской оболочки.
COMMAND6
COMMAND7
</source> 
Как вариант использования подоболочки — проверка переменных.
<source lang="bash">
if (set -u; : $variable) 2> /dev/null
then
echo "Переменная определена."
fi # Переменная была инициализирована в данном сценарии
# или это внутренняя переменная Bash
# или это переменная окружения (была экспортирована в оболочку).

# Можно сделать то же самое по другому: [[ ${variable-x} != x || ${variable-y} != y ]]
# или [[ ${variable-x} != x$variable ]]
# или [[ ${variable+x} = x ]])
# или [[ ${variable-x} != x ]])
</source> 
Ещё одно применение — проверка файлов блокировки:
<source lang="bash">
if (set -C; : > lock_file) 2> /dev/null
then
: # lock_file отсутствует: программа (сценарий) не запущена
else
echo "Этот сценарий уже запущен другим пользователем."
exit 65
fi
# Автор фрагмента Stephane Chazelas,
# небольшие дополнения сделаны Paulo Marcel Coelho Aragao.
</source> 
Процессы в подоболочках могут исполняться параллельно. Это позволяет разбить сложную задачу на несколько простых подзадач, выполняющих параллельную обработку информации.
 '''Пример''': '''''Запуск нескольких процессов в подоболочках.'''''
<source lang="bash">
(cat list1 list2 list3 | sort | uniq > list123) &
(cat list4 list5 list6 | sort | uniq > list456) &
# Слияние и сортировка двух списков производится одновременно.
# Запуск в фоне гарантирует параллельное исполнение.
#
# Тот же эффект даёт
# cat list1 list2 list3 | sort | uniq > list123 &
# cat list4 list5 list6 | sort | uniq > list456 &

wait # Ожидание завершения работы подоболочек.

diff list123 list456
</source> 
Перенаправление ввода/вывода в/из подоболочки производится оператором построения конвейера "'''|'''", например, '''''ls -al | (command)'''''. 
Блок команд, заключенный в фигурные скобки не приводит к запуску дочерней подоболочки.
''{ command1; command2; command3; ... }''

== Ограниченный режим командной оболочки ==
'''Команды, запрещённые в ограниченном режиме командной оболочки''' 
Запуск сценария или его части в ограниченном режиме, приводит к наложению ограничений на использование некоторых команд. Эта мера предназначена для ограничения привилегий пользователя, запустившего сценарий, и минимизации возможного ущерба системе, который может нанести сценарий.
:'''''В ограниченном режиме запрещена команда [[cd]] — смена текущего каталога.'''''
:'''''Запрещено изменять переменные окружения $PATH, $SHELL, $BASH_ENV и $ENV.'''''
:'''''Запрещён доступ к переменной $SHELLOPTS.'''''
:'''''Запрещено перенаправление вывода.'''''
:'''''Запрещён вызов утилит, в названии которых присутствует хотя бы один символ "слэш" (''/'').'''''
:'''''Запрещён вызов команды '''''exec''''' для запуска другого процесса.'''''
:'''''Запрещён ряд других команд, которые могут использовать сценарий для выполнения непредусмотренных действий.'''''
:'''''Запрещён выход из ограниченного режима.'''''
 '''Пример''': '''''Запуск сценария в ограниченном режиме.'''''
<source lang="bash">
#!/bin/bash
# Если sha-bang задать в таком виде: "#!/bin/bash -r"
# то это приведёт к включению ограниченного режима с момента запуска скрипта.

echo
echo "Смена каталога."
cd /usr/local
echo "Текущий каталог: `pwd`"
echo "Переход в домашний каталог."
cd
echo "Текущий каталог: `pwd`"
echo
# До сих пор сценарий исполнялся в обычном, неограниченном режиме.
set -r
# set --restricted имеет тот же эффект.
echo "==> Переход в ограниченный режим. <=="

echo
echo

echo "Попытка сменить текущий каталог в ограниченном режиме."

cd ..
echo "Текущий каталог остался прежним: `pwd`"

echo
echo

echo "\$SHELL = $SHELL"
echo "Попытка смены командного интерпретатора в ограниченном режиме."
SHELL="/bin/ash"
echo
echo "\$SHELL= $SHELL"

echo
echo

echo "Попытка перенаправления вывода в ограниченном режиме."
ls -l /usr/bin > bin.files
ls -l bin.files # Попробуем найти файл, который пытались создать.

echo

exit 0
</source> 

== Подстановка процессов ==
''Подстановка процессов'' — это аналог подстановки команд. Операция подстановки команд записывает в переменную результат выполнения некоторой команды, например, ''dir_contents=`ls -al`'' или ''xref=$(grep word datafile)''. Операция подстановки процессов передаёт вывод одного процесса на ввод другого (другими словами, передаёт результат выполнения одной команды — другой). 

'''Шаблон подстановки команды''' 
Внутри круглых скобок:
:<big>'''>(command)'''</big>
:<big>'''<(command)'''</big>
:Таким образом инициируется подстановка процессов. Здесь, для передачи результата работы процесса в круглых скобках, используются файлы ''/dev/fd/<n>''. Между круглой скобкой и символом "'''<'''" или "'''>'''", не должно быть пробелов, в противном случае это вызовет сообщение об ошибке.
<source lang="bash">
bash$ echo >(true)
/dev/fd/63

bash$ echo <(true)
/dev/fd/63
</source> 
Bash создаёт канал с двумя файловыми дескрипторами, ''--fIn'' и ''fOut--''. ''stdin'' команды ''true'' присоединяется к ''fOut'' (dup2(fOut, 0)), затем Bash передаёт ''/dev/fd/fIn'' в качестве аргумента команде [[echo]]. В системах, где отсутствуют файлы ''/dev/fd/<n>'', Bash может использовать временные файлы. (Спасибо S.C.) 
<source lang="bash">
cat <(ls -l)
# То же самое, что и ls -l | cat

sort -k 9 <(ls -l /bin) <(ls -l /usr/bin) <(ls -l /usr/X11R6/bin)
# Список файлов в трёх основных каталогах 'bin', отсортированный по именам файлов.
# Обратите внимание: на вход 'sort' поданы три самостоятельные команды.

diff <(command1) <(command2) # Выдаст различия в выводе команд.

tar cf >(bzip2 -c > file.tar.bz2) $directory_name
# Вызовет "tar cf /dev/fd/?? $directory_name" и затем "bzip2 -c > file.tar.bz2".
#
# Из-за особенностей, присущих некоторым системам, связанным с /dev/fd/<n>,
# канал между командами не обязательно должен быть именованным.
#
# Это можно сделать и так.
#
bzip2 -c < pipe > file.tar.bz2&
tar cf pipe $directory_name
rm pipe
# или
exec 3>&1tar cf /dev/fd/4 $directory_name 4>&1 >&3 3>&- | bzip2 -c > file.tar.bz2 3>&-
exec 3>&-
# Спасибо S.C.
</source> 
Ниже приводится ещё один очень интересный пример использования подстановки процессов. 
<source lang="bash">
# Фрагмент сценария из дистрибутива SuSE:
while read des what mask iface; do
# Некоторые команды ...
done < <(route -n)

# Чтобы проверить это, попробуем вставить команду, выполняющую какие-либо действия.
while read des what mask iface; do
echo $des $what $mask $iface
done < <(route -n)

# Вывод на экран:
# Kernel IP routing table
# Destination Gateway Genmask Flags Metric Ref Use Iface
# 127.0.0.0 0.0.0.0 255.0.0.0 U 0 0 0 lo
# Как указывает S.C. — более простой для понимания эквивалент:
route -n |
while read des what mask iface; do # Переменные берут значения с устройства вывода конвейера (канала).
echo $des $what $mask $iface
done # На экран выводится то же самое, что и выше.
# Однако, Ulrich Gayer отметил, что ...
# этот вариант запускает цикл while в подоболочке, этот вариант запускает цикл while в подоболочке,
# и поэтому переменные не видны за пределами цикла, после закрытия канала.
</source> 

== Функции ==
Подобно "настоящим" языкам программирования, Bash тоже имеет функции, хотя и в несколько ограниченном варианте. Функция — это подпрограмма, блок кода который реализует набор операций, своего рода "чёрный ящик", предназначенный для выполнения конкретной задачи. Функции могут использоваться везде, где имеются участки повторяющегося кода. 

'''function''' ''function_name'' { 
''command...'' 
} 

или

''function_name'' () {command...} 
Вторая форма записи ближе к сердцу C-программистам (она же более переносимая). Как и в языке C, скобка, открывающая тело функции, может помещаться на следующей строке. 
'''function_name ()''' 
{ 
''command...'' 
} 
Вызов функции осуществляется простым указанием её имени в тексте сценария. 
 '''Пример''': '''''Простые функции.'''''
<source lang="bash">
#!/bin/bash
JUST_A_SECOND=1
funky ()
{ # Это пример простейшей функции, которая выводит сообщение.
echo "Это функция funky."
} # Объявление функции должно предшествовать её вызову.

fun ()
{ # Более сложная функция.
i=0
REPEATS=30

echo
echo "Теперь запускается функция fun."
echo

sleep $JUST_A_SECOND # Эй! Погодите секундочку!
while [ $i -lt $REPEATS ]
do
echo "------------------РАБОТА------------------->"
echo "<---------------С ФУНКЦИЯМИ----------------"
echo "<------------ОЧЕНЬ УВЛЕКАТЕЛЬНА------------>"
echo
let "i+=1"
done
}
# А теперь собственно вызов функций.
funky
fun

exit 0
</source> 
Функция должна быть объявлена раньше, чем её можно будет использовать. К сожалению, в Bash нет возможности "опережающего объявления" функции, как например в C.
<source lang="bash">
f1
# Эта строка вызовет сообщение об ошибке, поскольку функция "f1" еще не определена.

declare -f f1 # Это не поможет.
f1 # По прежнему — сообщение об ошибке.

# Однако...

f1 ()
{
echo "Вызов функции \"f2\" из функции \"f1\"."
f2
}

f2 ()
{
echo "Функция \"f2\"."
}

f1 # Функция "f2", фактически, не вызывается выше этой строки,
# хотя ссылка на неё встречается выше, до её объявления.
# Это допускается.
# Спасибо S.C.
</source> 
Допускается даже создание вложенных функций, хотя пользы от этого немного. 
<source lang="bash">
f1 ()
{
f2 () # вложенная
{
echo "Функция \"f2\", вложенная в \"f1\"."
}
}
f2 # Вызывает сообщение об ошибке.
# Даже "declare -f f2" не поможет.
echo
f1 # Ничего не происходит, простой вызов "f1", не означает автоматический вызов "f2".
f2 # Теперь всё нормально, вызов "f2" не приводит к появлению ошибки,
# поскольку функция "f2" была определена в процессе вызова "f1".
# Спасибо S.C.
</source> 
Объявление функции может размещаться в самых неожиданных местах. 
<source lang="bash">
ls -l | foo() { echo "foo"; } # Допустимо, но бесполезно.
if [ "$USER" = bozo ]
then
bozo_greet () # Объявление функции размещено в условном операторе.
{
echo "Привет, Bozo!"
}
fi
bozo_greet # Работает только у пользователя bozo, другие получат сообщение об ошибке.
# Нечто подобное можно использовать с определённой пользой для себя.
NO_EXIT=1 # Will enable function definition below.

[[ $NO_EXIT -eq 1 ]] && exit() { true; } # Определение функции в последовательности "И-список".
# Если $NO_EXIT равна 1, то объявляется "exit ()".
# Тем самым, функция "exit" подменяет встроенную команду "exit".

exit # Вызывается функция "exit ()", а не встроенная команда "exit".
# Спасибо S.C.
</source> 
=== Сложные функции и сложности с функциями ===
Функции могут принимать входные аргументы и возвращать код завершения. 
<source lang="bash">function_name $arg1 $arg2</source> 
Доступ к входным аргументам, в функциях, производится посредством позиционных параметров, т.е. '''$1''', '''$2''' и так далее.
 '''Пример''': '''''Функция с аргументами.'''''
<source lang="bash">
#!/bin/bash
# Функции и аргументы

DEFAULT=default # Значение аргумента по-умолчанию.

func2 () {
if [ -z "$1" ] # Длина аргумента #1 равна нулю?
then
echo "-Аргумент #1 имеет нулевую длину.-" # Или аргумент не был передан функции.
else
echo "-Аргумент #1: \"$1\".-"
fi

variable=${1-$DEFAULT} # Что делает
echo "variable = $variable" # показанная подстановка параметра?
# ---------------------------
# Она различает отсутствующий аргумент от "пустого" аргумента.

if [ "$2" ]
then
echo "-Аргумент #2: \"$2\".-"
fi
return 0
}

echo

echo "Вызов функции без аргументов."
func2
echo

echo "Вызов функции с \"пустым\" аргументом."
func2 ""
echo

echo "Вызов функции с неинициализированным аргументом."
func2 "$uninitialized_param"
echo

echo "Вызов функции с одним аргументом."
func2 first
echo

echo "Вызов функции с двумя аргументами."
func2 first second
echo

echo "Вызов функции с аргументами \"\" \"second\"."
func2 "" second # Первый параметр "пустой"
echo # и второй параметр — ASCII-строка.
exit 0
</source> 
Команда '''''shift''''' вполне применима и к аргументам функций. 
В отличие от других языков программирования, в сценариях на языке командной оболочки, аргументы в функции передаются по значению. Переменные (которые фактически являются указателями) при передаче в функции в виде параметров, интерпретируются как строковые литералы. Функции всегда интерпретируют свои аргументы буквально. Механизм косвенных ссылок на переменные слишком неудобен для передачи аргументов по ссылке. 
 '''Пример''': '''''Передача косвенных ссылок в функцию.'''''
<source lang="bash">
#!/bin/bash
# ind-func.sh: Передача косвенных ссылок в функцию.
echo_var ()
{
echo "$1"
}
message=Hello
Hello=Goodbye

echo_var "$message" # Hello
# А теперь передадим функции косвенную ссылку.

echo_var "${!message}" # Goodbyeecho "-------------"

echo "-------------"

# Что произойдёт, если изменить содержимое переменной "Hello"?
Hello="Hello, again!"
echo_var "$message" # Hello
echo_var "${!message}" # Hello, again!

exit 0
</source> 
Тут же возникает вопрос: "Возможно ли изменить значение переменной, которая была передана по ссылке?"
 '''Пример''': '''''Изменение значения переменной, переданной в функцию по ссылке.'''''
<source lang="bash">
#!/bin/bash
# dereference.sh
# Изменение значения переменной, переданной в функцию по ссылке.
# Автор: Bruce W. Clare.
dereference ()
{
y=\$"$1" # Имя переменной.
echo $y # $Junk

x=`eval "expr \"$y\" "`
echo $1=$x
eval "$1=\"Некий другой текст \"" # Присвоить новое значение.
}
Junk="Некий текст"
echo $Junk "до того как..." # Некий текст до того как...

dereference Junk
echo $Junk "после того как..." # Некий другой текст после того как...

exit 0
</source> 
 '''Пример''': '''''Ещё один пример разыменования параметров функции, передаваемых по ссылке.'''''
<source lang="bash">
#!/bin/bash
ITERATIONS=3 # Количество вводимых значений.
icount=1

my_read () {
# При вызове my_read varname,
# выводит предыдущее значение в квадратных скобках,
# затем просит ввести новое значение.

local local_var

echo -n "Введите говое значение переменной "
eval 'echo -n "[$'$1'] "' # Прежнее значение.
read local_var
[ -n "$local_var" ] && eval $1=\$local_var
# Последовательность "And-list": если "local_var" не пуста, то ее значение переписывается в "$1".
}
echo
while [ "$icount" -le "$ITERATIONS" ]
do
my_read var
echo "Значение #$icount = $var"
let "icount += 1"
echo
done
# Спасибо Stephane Chazelas за этот поучительный пример.
exit 0
</source> 
<big>'''Exit and Return'''</big> 
'''Код завершения''' 
Функции возвращают значение в виде кода завершения. Код завершения может быть задан явно, с помощью команды ''return'', в противном случае будет возвращен код завершения последней команды в функции ('''0''' — в случае '''успеха''', иначе — '''ненулевой код ошибки'''). Код завершения в сценарии может быть получен через переменную '''''$?'''''. 
'''return''' 
Завершает исполнение функции. Команда ''return'' может иметь необязательный аргумент типа ''integer'', который возвращается в вызывающий сценарий как "код завершения" функции, это значение так же записывается в переменную '''''$?'''''.
 '''Пример''': '''''Наибольшее из двух чисел.'''''
<source lang="bash">
#!/bin/bash
# max.sh: Наибольшее из двух целых чисел.

E_PARAM_ERR=-198 # Если функции передано меньше двух параметров.
EQUAL=-199 # Возвращаемое значение, если числа равны.

max2 () # Возвращает наибольшее из двух чисел.
{ # Внимание: сравниваемые числа должны быть меньше 257.
if [ -z "$2" ]
then
return $E_PARAM_ERR
fi
if [ "$1" -eq "$2" ]
then
return $EQUAL
else
if [ "$1" -gt "$2" ]
then
return $1
else
return $2
fi
fi
}

max2 33 34
return_val=$?

if [ "$return_val" -eq $E_PARAM_ERR ]
then
echo "Функции должно быть передано два аргумента."
elif [ "$return_val" -eq $EQUAL ]
then
echo "Числа равны."
else
echo "Наибольшее из двух чисел: $return_val."
fi

exit 0

# Упражнение:
# ---------------
# Сделайте этот сценарий интерактивным,
# т.е. заставьте сценарий запрашивать числа для сравнения у пользователя (два числа).
</source> 
Для случаев, когда функция должна возвращать строку или массив, используйте специальные переменные. 
<source lang="bash">
count_lines_in_etc_passwd()
{
[[ -r /etc/passwd ]] && REPLY=$(echo $(wc -l < /etc/passwd))
# Если файл /etc/passwd доступен на чтение, то в переменную REPLY заносится число строк.
# Возвращаются как количество строк, так и код завершения.
# Команда 'echo' может показаться ненужной, но . . .
# она предотвращает вывод лишних пробелов.
}

if count_lines_in_etc_passwd
then
echo "В файле /etc/passwd найдено $REPLY строк."
else
echo "Невозможно подсчитать число строк в файле /etc/passwd."
fi
# Спасибо S.C.
</source> 
 '''Пример''': '''''Преобразование чисел в римскую форму записи.'''''
<source lang="bash">
#!/bin/bash
# Преобразование чисел из арабской формы записи в римскую
# Диапазон: 0 - 200

# Расширение диапазона представляемых чисел и улучшение сценария
# оставляю вам, в качестве упражнения.

# Порядок использования: roman number-to-convert\
LIMIT=200
E_ARG_ERR=65
E_OUT_OF_RANGE=66
if [ -z "$1" ]
then
echo "Порядок использования: `basename $0` number-to-convert"
exit $E_ARG_ERR
fi

num=$1
if [ "$num" -gt $LIMIT ]
then
echo "Выход за границы диапазона!"
exit $E_OUT_OF_RANGE
fi

to_roman () # Функция должна быть объявлена до того как она будет вызвана.
{
number=$1
factor=$2
rchar=$3
let "remainder = number - factor"
while [ "$remainder" -ge 0 ]
do
echo -n $rchar
let "number -= factor"
let "remainder = number - factor"
done

return $number
# Упражнение:
# --------
# Объясните — как работает функция.
# Подсказка: деление последовательным вычитанием.
}

to_roman $num 100 Cnum=$?
num=$?
to_roman $num 90 LXXXX
num=$?
to_roman $num 50 L
num=$?
to_roman $num 40 X
Lnum=$?
to_roman $num 10 X
num=$?
to_roman $num 9 IX
num=$?
to_roman $num 5 V
num=$?
to_roman $num 4 IV
num=$?
to_roman $num 1 I
echo
exit 0
</source> 
Наибольшее положительное целое число, которое может вернуть функция — 255. Команда ''return'' очень тесно связана с понятием код завершения, что объясняет это специфическое ограничение. К счастью существуют различные способы преодоления этого ограничения.
 '''Пример''': '''''Проверка возможности возврата функциями больших значений.'''''
<source lang="bash">
#!/bin/bash
# return-test.sh
# Наибольшее целое число, которое может вернуть функция, не может превышать 256.

return_test () # Просто возвращает то, что ей передали.
{
return $1
}

return_test 27 # o.k.
echo $? # Возвращено число 27.

return_test 255 # o.k.
echo $? # Возвращено число 255.

return_test 257 # Ошибка!
echo $? # Возвращено число 1.

return_test -151896 # Как бы то ни было, но для больших отрицательных чисел проходит!
echo $? # Возвращено число -151896.

exit 0
</source> 
Самый простой способ вернуть из функции большое положительное число — это присвоить "возвращаемое значение" глобальной переменной.
<source lang="bash">
Return_Val= # Глобальная переменная, которая хранит значение, возвращаемое функцией.
alt_return_test ()
{
fvar=$1
Return_Val=$fvar
return # Возвратить 0 (успешное завершение).
}

alt_return_test 1
echo $? # 0
echo "Функция вернула число $Return_Val" # 1
alt_return_test 255
echo "Функция вернула число $Return_Val" # 255
alt_return_test 257
echo "Функция вернула число $Return_Val" # 257
alt_return_test 25701
echo "Функция вернула число $Return_Val" #25701
</source> 
Ещё более элегантный способ заключается в передаче возвращаемого значения команде [[echo]], для вывода на ''stdout'', которое затем снимается со стандартного вывода конструкцией подстановки команд.
 '''Пример''': '''''Сравнение двух больших целых чисел.'''''
<source lang="bash">
#!/bin/bash
# max2.sh: Наибольшее из двух БОЛЬШИХ целых чисел.

# Это модификация предыдущего примера "max.sh",
# которая позволяет выполнять сравнение больших целых чисел.

EQUAL=0 # Если числа равны.
MAXRETVAL=255 # Максимально возможное положительное число, которое может вернуть функция.
E_PARAM_ERR=-99999 # Код ошибки в параметрах.
E_NPARAM_ERR=99999 # "Нормализованный" код ошибки в параметрах.

max2 () # Возвращает наибольшее из двух больших целых чисел.
{
if [ -z "$2" ]
then
return $E_PARAM_ERR
fi
if [ "$1" -eq "$2" ]
then
return $EQUAL
else
if [ "$1" -gt "$2" ]
then
retval=$1
else
retval=$2
fi
fi
# -------------------------------------------------------------- #
# Следующие строки позволяют "обойти" ограничение
if [ "$retval" -gt "$MAXRETVAL" ] # Если больше предельного значения,
then # то
let "retval = (( 0 - $retval ))" # изменение знака числа.
# (( 0 - $VALUE )) изменяет знак числа.
fi
# Функции имеют возможность возвращать большие *отрицательные* числа.
# -------------------------------------------------------------- #

return $retval
}

max2 33001 33997
return_val=$?

# --------------------------------------------------------------------------
#
if [ "$return_val" -lt 0 ] # Если число отрицательное,
then # то
let "return_val = (( 0 - $return_val ))" # опять изменить его знак.
fi # "Абсолютное значение" переменной $return_val.
# --------------------------------------------------------------------------
#

if [ "$return_val" -eq "$E_NPARAM_ERR" ]
then # Признак ошибки в параметрах, при выходе из функции так же поменял знак.
echo "Ошибка: Недостаточно аргументов."
elif [ "$return_val" -eq "$EQUAL" ]
then
echo "Числа равны."
else
echo "Наибольшее число: $return_val."
fi
exit 0
</source> 
'''''Упражнение''''': Используя только что полученные знания, добавьте в предыдущий пример, преобразования чисел в римскую форму записи, возможность обрабатывать большие числа. 
'''Перенаправление''' 
''Перенаправление ввода для функций'' 
Функции — суть есть блок кода, а это означает, что устройство ''stdin'' для функций может быть переопределено (перенаправление ''stdin''). 
 '''Пример''': '''''Настоящее имя пользователя.'''''
<source lang="bash">
#!/bin/bash
# По имени пользователя получить его "настоящее имя" из /etc/passwd.

ARGCOUNT=1 # Ожидается один аргумент.
E_WRONGARGS=65
file=/etc/passwd
pattern=$1

if [ $# -ne "$ARGCOUNT" ]
then
echo "Порядок использования: `basename $0` USERNAME"
exit $E_WRONGARGS
fi

file_excerpt () # Производит поиск в файле по заданному шаблону, выводит требуемую часть строки.
{
while read line
do
echo "$line" | grep $1 | awk -F":" '{ print $5 }' # Указывает awk использовать ":" как разделитель полей.
done
} <$file # Подменить stdin для функции.

file_excerpt $pattern
# Да, этот сценарий можно уменьшить до
# grep PATTERN /etc/passwd | awk -F":" '{ print $5 }'
# или
# awk -F: '/PATTERN/ {print $5}'
# или
# awk -F: '($1 == "username") { print $5 }'
# Однако, это было бы не так поучительно.

exit 0
</source> 
Ниже приводится альтернативный, и возможно менее запутанный, способ перенаправления ввода для функций. Он заключается в использовании перенаправления ввода для блока кода, заключенного в фигурные скобки, в пределах функции. 
<source lang="bash">
# Вместо:
Function ()
{
...
} < file

# Попробуйте так:
Function ()
{
{
...
} < file
}

# Похожий вариант,
Function () # Тоже работает.
{
{
echo $*
} | tr a b
}

Function () # Этот вариант не работает.
{
echo $*
} | tr a b # Наличие вложенного блока кода — обязательное условие.

# Спасибо S.C.
</source> 
=== Локальные переменные ===
'''Что такое "локальная" переменная?''' 
Локальные переменные 
Переменные, объявленные как локальные, имеют ограниченную область видимости, и доступны только в пределах блока, в котором они были объявлены. Для функций это означает, что локальная переменная "видна" только в теле самой функции. 
 '''Пример''': '''''Область видимости локальных переменных.'''''
<source lang="bash">
#!/bin/bash

func ()
{
local loc_var=23 # Объявление локальной переменной.
echo
echo "\"loc_var\" в функции = $loc_var"
global_var=999 # Эта переменная не была объявлена локальной.
echo "\"global_var\" в функции = $global_var"
}

func
# Проверим, "видна" ли локальная переменная за пределами функции.

echo
echo "\"loc_var\" за пределами функции = $loc_var"
# "loc_var" за пределами функции =
# Итак, $loc_var не видна в глобальном контексте.
echo "\"global_var\" за пределами функции = $global_var"
# "global_var" за пределами функции = 999
# $global_var имеет глобальную область видимости.
echo

exit 0
</source> 
Переменные, объявляемые в теле функции, считаются необъявленными до тех пор, пока функция не будет вызвана. Это касается всех переменных. 
<source lang="bash">
#!/bin/bash

func ()
{
global_var=37 # Эта переменная будет считаться необъявленной
# до тех пор, пока функция не будет вызвана.
} # КОНЕЦ ФУНКЦИИ
echo "global_var = $global_var" # global_var =
# Функция "func" ещё не была вызвана,
# поэтому $global_var пока ещё не "видна" здесь.

func

echo "global_var = $global_var" # global_var = 37
# Переменная была инициализирована в функции.
</source> 
==== Локальные переменные делают возможной рекурсию. ====
Хотя локальные переменные и допускают рекурсию, но она сопряжена с большими накладными расходами и не рекомендуется для использования в сценариях.
 '''Пример''': '''''Использование локальных переменных при рекурсии.'''''
<source lang="bash">
#!/bin/bash
# факториал
# ---------

# Действительно ли bash допускает рекурсию?
# Да! Но...
# Нужно быть действительно дубинноголовым, чтобы использовать её в сценариях
# на языке командной оболочки.

MAX_ARG=5
E_WRONG_ARGS=65
E_RANGE_ERR=66

if [ -z "$1" ]
then
echo "Порядок использования: `basename $0` число"
exit $E_WRONG_ARGS
fi
if [ "$1" -gt $MAX_ARG ]
then
echo "Выход за верхний предел (максимально возможное число -- 5)."
# Вернитесь к реальности.
# Если вам захочется поднять верхнюю границу,
# то перепишите эту программу на настоящем языке программирования.
exit $E_RANGE_ERR
fi

fact ()
{
local number=$1
# Переменная "number" должна быть объявлена как локальная,
# иначе результат будет неверный.
if [ "$number" -eq 0 ]
then
factorial=1 # Факториал числа 0 = 1.
else
let "decrnum = number - 1"
fact $decrnum # Рекурсивный вызов функции.
let "factorial = $number * $?"
fi
return $factorial
}

fact $1
echo "Факториал числа $1 = $?."

exit 0
</source> 
Не забывайте, что рекурсия весьма ресурсоёмкое удовольствие, к тому же она выполняется слишком медленно, поэтому не следует использовать её в сценариях.

=== Рекурсия без локальных переменных ===
Функции допускают выполнять рекурсивный вызов даже без использования локальных переменных. 
 '''Пример''': '''''Ханойские Башни.'''''
<source lang="bash">
#! /bin/bash
#
# Ханойские Башни
# Bash script# Copyright (C) 2000 Amit Singh. All Rights Reserved.
# http://hanoi.kernelthread.com
#
# Тестировался под bash 2.05b.0(13)-release
#
# Используется в "Advanced Bash Scripting Guide"
# с разрешения автора.
# С небольшими изменениями, внесенными автором документа.

#=================================================================#
# Ханойские Башни — это древняя математическая головоломка.
# Дается три вертикальных стержня.
# На первый нанизан набор колец.
# Эти кольца представляют собой плоские диски с дыркой по-середине,
# так что они могут свободно скользить по стержню.
# Кольца имеют различный диаметр, и изначально расположены на первом стержне
# в порядке убывания их диаметров.
# Наименьшее кольцо расположено сверху, наибольшее — внизу.
#
# Суть задачи заключается в том, чтобы перенести кольца с первого
# стержня на последний так, чтобы порядок следования колец не изменился.
# Кольца можно перемещать со стержня на стержень только по одному за раз.
# Можно помещать кольца обратно на тот же самый стержень.
# При перемещении нельзя класть больший диск на меньший.
#
# Для небольшого количества колец требуется некоторое количество перемещений.
# Каждое дополнительное кольцо
# увеличивает необходимое количество перемещений примерно в два раза,
# при этом "стратегия" перемещения усложняется все больше и больше.
#
# За дополнительной информацией обращайтесь на http://hanoi.kernelthread.com.
#
#
#
# ... ... ...
# | | | | | |
# _|_|_ | | | |
# |_____| | | | |
# |_______| | | | |
# |_________| | | | |
# |___________| | | | |
# | | | | | |
# .--------------------------------------------------------------.
# |**************************************************************|
# #1 #2 #3#
#=================================================================#

E_NOPARAM=66 # Сценарий запущен без параметров.
E_BADPARAM=67 # Неверное число колец.
Moves= # Глобальная переменная, хранит число перемещений.
# Добавлено в оригинальный сценарий.

dohanoi() { # Рекурсивная функция.
case $1 in
0)
;;
*)
dohanoi "$(($1-1))" $2 $4 $3
echo move $2 "-->" $3
let "Moves += 1" # Добавлено в оригинальный сценарий.
dohanoi "$(($1-1))" $4 $3 $2
;;
esac
}

case $# in
1)
case $(($1>0)) in # Как минимум должен быть хотя бы один диск.
1)
dohanoi $1 1 3 2
echo "Всего перемещений = $Moves"
exit 0;
;;
*)
echo "$0: Неверное число колец";
exit $E_BADPARAM;
;;
esac
;;
*)
echo "Порядок использования: $0 N"
echo " Где \"N\" — это число колец."
exit $E_NOPARAM;
;;
esac
# Упражнения:
# ---------
# 1) Будут ли исполнены дополнительные команды, если разместить их ниже этой строки?
# Почему нет? (Это так просто!)
# 2) Объясните — как работает функция "dohanoi".
# (А вот это уже сложнее)
</source> 

== Псевдонимы ==
''Псевдонимы'' в Bash — это ни что иное, как "горячие клавиши", средство, позволяющее избежать набора длинных строк в командной строке. Если, к примеру, в файл
''~/.bashrc'' вставить строку '''''alias lm="ls -l | more"''''', то потом вы сможете экономить свои силы и время, набирая команду '''lm'', вместо более длинной '''''ls -l | more'''''. Установив '''''alias rm="rm -i"''''' (интерактивный режим удаления файлов), Вы сможете избежать многих неприятностей, потому что сократится вероятность удаления важных файлов по неосторожности. 
Псевдонимы в сценариях могут иметь весьма ограниченную область применения. Было бы здорово, если бы псевдонимы имели функциональность, присущую макроопределениям в языке C, но, к сожалению, Bash не может "разворачивать" аргументы в теле псевдонима. Кроме того, попытка обратиться к псевдониму, созданному внутри "составных конструкций", таких как ''if/then'', циклы и функции, будет приводить к появлению ошибок. Практически всегда, действия, возлагаемые на псевдоним, более эффективно могут быть выполнены с помощью функций.
 '''Пример''': '''''Псевдонимы в сценарии.'''''
<source lang="bash">
#!/bin/bash
shopt -s expand_aliases
# Эта опция должна быть включена, иначе сценарий не сможет "разворачивать" псевдонимы.

alias ll="ls -l"
# В определении псевдонима можно использовать как одиночные ('), так и двойные (") кавычки.

echo "Попытка обращения к псевдониму \"ll\":"
ll /usr/X11R6/bin/mk* #* Работает.

echo

directory=/usr/X11R6/bin/
prefix=mk* # Определить -- не будет ли проблем с шаблонами.
echo "Переменные \"directory\" + \"prefix\" = $directory$prefix"
echo

alias lll="ls -l $directory$prefix"
echo "Попытка обращения к псевдониму \"lll\":"
lll # Список всех файлов в /usr/X11R6/bin, чьи имена начинаются с mk.
# Псевдонимы могут работать с шаблонами.
TRUE=1
echo
if [ TRUE ]
then
alias rr="ls -l"
echo "Попытка обращения к псевдониму \"rr\", созданному внутри if/then:"
rr /usr/X11R6/bin/mk* #* В результате -- сообщение об ошибке!
# К псевдонимам, созданным внутри составных инструкций, нельзя обратиться.
echo "Однако, ранее созданный псевдоним остается работоспособным:"
ll /usr/X11R6/bin/mk*
fi
echo

count=0
while [ $count -lt 3 ]
do
alias rrr="ls -l"
echo "Попытка обращения к псевдониму \"rrr\", созданному внутри цикла \"while\":"
rrr /usr/X11R6/bin/mk* #* Так же возникает ошибка.
# alias.sh: line 57: rrr: command not found
let count+=1
done

echo; echo

alias xyz='cat $0' # Сценарий печатает себя самого.
# Обратите внимание на "строгие" кавычки.
xyz
# Похоже работает,
# хотя документация Bash утверждает, что такой псевдоним не должен работать.
#
# Steve Jacobson отметил, что параметр "$0" интерпретируется непосредственно, во время объявления псевдонима.

exit 0
</source> 
Команда '''''unalias''''' удаляет псевдоним, объявленный ранее.
 '''Пример''': '''''unalias: Объявление и удаление псевдонимов.'''''
<source lang="bash">
#!/bin/bash
shopt -s expand_aliases # Разрешить "разворачивание" псевдонимов.

alias llm='ls -al | more'
llm

echo

unalias llm # Удалить псевдоним.
llm
# Сообщение об ошибке, т.к. команда 'llm' больше не распознается.
exit 0
</source> 
<source lang="bash">
bash$ ./unalias.sh
total 6
drwxrwxr-x 2 bozo bozo 3072 Feb 6 14:04 .
drwxr-xr-x 40 bozo bozo 2048 Feb 6 14:04 ..
-rwxr-xr-x 1 bozo bozo 199 Feb 6 14:04 unalias.sh
./unalias.sh: llm: command not found
</source> 

== Списки команд ==
Средством обработки последовательности из нескольких команд служат списки: "''И-списки''" и "''ИЛИ-списки''". Они эффективно могут заменить сложную последовательность вложенных '''''if/then''''' или даже '''''case'''''. 
'''Объединение команд в цепочки''' 
<big>''И-список''</big> 
''command-1 && command-2 && command-3 && ... command-n'' 
Каждая последующая команда, в таком списке, выполняется только тогда, когда предыдущая команда вернула код завершения ''true''(ноль). Если какая-либо из команд возвращает ''false''(не ноль), то исполнение списка команд в этом месте завершается, т.е. следующие далее команды не выполняются. 
 '''Пример''': '''''Проверка аргументов командной строки с помощью "И-списка".'''''
<source lang="bash">
#!/bin/bash
# "И-список"

if [ ! -z "$1" ] && echo "Аргумент #1 = $1" && [ ! -z "$2" ] && echo "Аргумент #2 = $2"
then
echo "Сценарию передано не менее 2 аргументов."
# Все команды в цепочке возвращают true.
else
echo "Сценарию передано менее 2 аргументов."
# Одна из команд в списке вернула false.
fi
# Обратите внимание: "if [ ! -z $1 ]" тоже работает, но, казалось бы эквивалентный вариант
# if [ -n $1 ] — нет. Однако, если добавить кавычки
# if [ -n "$1" ] то всё работает. Будьте внимательны!
# Проверяемые переменные лучше всегда заключать в кавычки.

# То же самое, только без списка команд.
if [ ! -z "$1" ]
then
echo "Аргумент #1 = $1"
fi
if [ ! -z "$2" ]
then
echo "Аргумент #2 = $2"
echo "Сценарию передано не менее 2 аргументов."
else
echo "Сценарию передано менее 2 аргументов."
fi
# Получилось менее элегантно и длиннее, чем с использованием "И-списка".

exit 0
</source> 
 '''Пример''': '''''Ещё один пример проверки аргументов с помощью "И-списков".'''''
<source lang="bash">
#!/bin/bash

ARGS=1 # Ожидаемое число аргументов.
E_BADARGS=65 # Код завершения, если число аргументов меньше ожидаемого.

test $# -ne $ARGS && echo "Порядок использования: `basename $0` $ARGS аргумент(а)(ов)" && exit $E_BADARGS
# Если проверка первого условия возвращает true (неверное число аргументов),
# то исполняется остальная часть строки, и сценарий завершается.

# Строка ниже выполняется только тогда, когда проверка выше не проходит.
# обратите внимание на условие "-ne" — "не равно" (прим. перев.)
echo "Сценарию передано корректное число аргументов."
exit 0
# Проверьте код завершения сценария командой "echo $?".
</source> 
Конечно же, с помощью ''И-списка'' можно присваивать переменным значения по-умолчанию. 
<source lang="bash">
arg1=$@ # В $arg1 записать аргументы командной строки.

[ -z "$arg1" ] && arg1=DEFAULT
# Записать DEFAULT, если аргументы командной строки отсутствуют.
</source> 
<big>''ИЛИ-список''</big> 
''command-1 || command-2 || command-3 || ... command-n'' 
Каждая последующая команда, в таком списке, выполняется только тогда, когда предыдущая команда вернула код завершения ''false''(не ноль). Если какая-либо из команд возвращает ''true''(ноль), то исполнение cписка команд в этом месте завершается, т.е. следующие далее команды не выполняются. Очевидно, что "''ИЛИ-списки''" имеют смысл обратный, по отношению к "''И-спискам''". 
 '''Пример''': '''''Ещё один пример проверки аргументов с помощью "И-списков".'''''
<source lang="bash">
#!/bin/bash
# delete.sh, утилита удаления файлов.
# Порядок использования: delete имя_файла
E_BADARGS=65if [ -z "$1" ]
then
echo "Порядок использования: `basename $0` имя_файла"
exit $E_BADARGS # Если не задано имя файла.
else
file=$1 # Запомнить имя файла.
fi

[ ! -f "$file" ] && echo "Файл \"$file\" не найден. \
Робкий отказ удаления несуществующего файла."
# И-СПИСОК, выдать сообщение об ошибке, если файл не существует.
# Обратите внимание: выводимое сообщение продолжается во второй строке,
# благодаря экранированию символа перевода строки.

[ ! -f "$file" ] || (rm -f $file; echo "Файл \"$file\" удален.")
# ИЛИ-СПИСОК, удаляет существующий файл.

# Обратите внимание на логические условия.
# И-СПИСОК отрабатывает по true, ИЛИ-СПИСОК -- по false.

exit 0
</source> 
'''''Списки возвращают код завершения последней выполненной команды'''''. 
Комбинируя "И" и "ИЛИ" списки, легко "перемудрить" с логическими условиями, поэтому, в таких случаях может потребоваться детальная отладка. 
<source lang="bash">
false && true || echo false # false
# Тот же результат даёт( false && true ) || echo false # false
# Но не эта комбинация
false && ( true || echo false ) # (нет вывода на экран)

# Обратите внимание на группировку и порядок вычисления условий — слева-направо,
# поскольку логические операции "&&" и "||" имеют равный приоритет.
# Если вы не уверены в своих действиях, то лучше избегать таких сложных конструкций.
# Спасибо S.C.
</source> 

== Массивы ==
Новейшие версии Bash поддерживают одномерные массивы. Инициализация элементов массива может быть произведена в виде: ''variable[xx]''. Можно явно объявить массив в сценарии, с помощью директивы declare: '''''declare -a variable'''''. Обращаться к отдельным элементам массива можно с помощью фигурных скобок, т.е.: ''${variable[xx]}''.
 '''Пример''': '''''Простой массив.'''''
<source lang="bash">
#!/bin/bash

area[11]=23
area[13]=37
area[51]=UFOs

# Массивы не требуют, чтобы последовательность элементов в массиве была непрерывной.
# Некоторые элементы массива могут оставаться неинициализированными.
# "Дырки" в массиве не являются ошибкой.

echo -n "area[11] = "
echo ${area[11]} # необходимы {фигурные скобки}

echo -n "area[13] = "
echo ${area[13]}

echo "содержимое area[51] = ${area[51]}."
# Обращение к неинициализированным элементам дает пустую строку.
echo -n "area[43] = "
echo ${area[43]}
echo "(элемент area[43] — неинициализирован)"

echo
# Сумма двух элементов массива, записанная в третий элемент
area[5]=`expr ${area[11]} + ${area[13]}`
echo "area[5] = area[11] + area[13]"
echo -n "area[5] = "
echo ${area[5]}

area[6]=`expr ${area[11]} + ${area[51]}`
echo "area[6] = area[11] + area[51]"
echo -n "area[6] = "
echo ${area[6]}
# Эта попытка закончится неудачей, поскольку сложение целого числа со строкой не допускается.

echo; echo; echo

# -----------------------------------------------------------------
# Другой массив, "area2".
# И другой способ инициализации массива...
# array_name=( XXX YYY ZZZ ... )

area2=( ноль один два три четыре )

echo -n "area2[0] = "
echo ${area2[0]}
# Ага, индексация начинается с нуля (первый элемент массива имеет индекс [0], а не [1]).

echo -n "area2[1] = "
echo ${area2[1]} # [1] -- второй элемент массива.
# -----------------------------------------------------------------

echo; echo; echo

# -----------------------------------------------
# Ещё один массив, "area3".
# И ещё один способ инициализации...
# array_name=([xx]=XXX [yy]=YYY ...)

area3=([17]=семнадцать [21]=двадцать_один)

echo -n "area3[17] = "
echo ${area3[17]}

echo -n "area3[21] = "
echo ${area3[21]}
# -----------------------------------------------

exit 0
</source> 
Bash позволяет оперировать переменными, как массивами, даже если они не были явно объявлены таковыми.
<source lang="bash">
string=abcABC123ABCabc
echo ${string[@]} # abcABC123ABCabc
echo ${string[*]} # abcABC123ABCabc
echo ${string[0]} # abcABC123ABCabc
echo ${string[1]} # Ничего не выводится! Почему?

echo ${#string[@]} # 1 Количество элементов в массиве.
# Спасибо Michael Zick за этот пример.
</source> 
Эти примеры ещё раз подтверждают отсутствие контроля типов в Bash. 
 '''Пример''': '''''Форматирование стихотворения.'''''
<source lang="bash">
#!/bin/bash
# poem.sh
# Строки из стихотворения (одна строфа).

Line[1]="Мой дядя самых честных правил,"
Line[2]="Когда не в шутку занемог;"
Line[3]="Он уважать себя заставил,"
Line[4]="И лучше выдумать не мог."
Line[5]="Его пример другим наука..."

# Атрибуты.
Attrib[1]=" А.С. Пушкин"
Attrib[2]="\"Евгений Онегин\""

for index in 1 2 3 4 5 # Пять строк.
do
printf " %s\n" "${Line[index]}"
done

for index in 1 2 # Две строки дополнительных атрибутов.
do
printf " %s\n" "${Attrib[index]}"
done

exit 0
</source> 
При работе с отдельными элементами массива можно использовать специфический синтаксис, даже стандартные команды и операторы Bash адаптированы для работы с массивами. 
 '''Пример''': '''''Различные операции над массивами.'''''
<source lang="bash">
#!/bin/bash
# array-ops.sh: Операции над массивами.

array=( ноль один два три четыре пять )

echo ${array[0]} # ноль
echo ${array:0} # ноль
# Подстановка параметра - первый элемент,
# начиная с позиции 0 (с 1-го символа).
echo ${array:1} # ноль
# Подстановка параметра - первый элемент,
# начиная с позиции 1 (со 2-го символа).

echo "--------------"

echo ${#array[0]} # 4
# Длина первого элемента массива.
echo ${#array} # 4
# Длина первого элемента массива.
# (Альтернативный вариант)
echo ${#array[1]} # 4
# Длина второго элемента массива.
# Индексация массивов в Bash начинается с нуля.
echo ${#array[*]} # 6
# Число элементов в массиве.
echo ${#array[@]} # 6
# Число элементов в массиве.

echo "--------------"

array2=( [0]="первый элемент" [1]="второй элемент" [3]="четвертый элемент" )

echo ${array2[0]} # первый элемент
echo ${array2[1]} # второй элемент
echo ${array2[2]} #
# Не был проинициализирован, поэтому null.
echo ${array2[3]} # четвёртый элемент

exit 0
</source> 
Большинство стандартных операций над строками применимы к массивам. 
 '''Пример''': '''''Строковые операции и массивы.'''''
<source lang="bash">
#!/bin/bash
# array-strops.sh: Строковые операции и массивы.
# Автор: Michael Zick.
# Используется с его разрешения.

# Как правило, строковые операции, в нотации ${name ... }
# могут использоваться для работы со строковыми элементами массивов
# в виде: ${name[@] ... } или ${name[*] ...} .

arrayZ=( one two three four five five )

echo
# Извлечение части строки
echo ${arrayZ[@]:0} # one two three four five five
# Все элементы массива.
echo ${arrayZ[@]:1} # two three four five five
# Все элементы массива, начиная со 2-го.
echo ${arrayZ[@]:1:2} # two three
# Два элемента массива, начиная со 2-го.
echo "-----------------------"

# Удаление части строки
# Удаляет наименьшую из подстрок, найденных по шаблону (поиск ведётся с начала строки)
# где шаблон — это регулярное выражение.

echo ${arrayZ[@]#f*r} # one two three five five
# Находит подстроку "four" и удаляет ее.
# Поиск ведётся по всем элементам массива

# Удаляет наибольшую подстроку, из найденных по шаблону
echo ${arrayZ[@]##t*e} # one two four five five
# Находит подстроку "three" и удаляет её.
# Поиск ведётся по всем элементам массива

# Удаляет наименьшую из подстрок, найденных по шаблону (поиск ведётся с конца строки)
echo ${arrayZ[@]%h*e} # one two t four five five
# Находит подстроку "hree" и удаляет её.
# Поиск ведется по всем элементам массива

# Удаляет наибольшую из подстрок, найденных по шаблону (поиск ведётся с конца строки)
echo ${arrayZ[@]%%t*e} # one two four five five
# Находит подстроку "three" и удаляет её.
# Поиск ведётся по всем элементам массива

echo "-----------------------"
# Замена части строки

# Заменяет первую найденную подстроку заданной строкой
echo ${arrayZ[@]/fiv/XYZ} # one two three four XYZe XYZe
# Поиск ведётся по всем элементам массива

# Заменяет все найденные подстроки
echo ${arrayZ[@]//iv/YY} # one two three four fYYe fYYe
# Поиск ведётся по всем элементам массива

# Удаляет все найденные подстроки
# Если замещающая строка не задана, то это означает "удаление"
echo ${arrayZ[@]//fi/} # one two three four ve ve
# Поиск ведется по всем элементам массива

# Заменяет первую найденную подстроку (поиск ведётся с начала строки)
echo ${arrayZ[@]/#fi/XY} # one two three four XYve XYve
# Поиск ведётся по всем элементам массива

# Заменяет первую найденную подстроку (поиск ведется с конца строки)
echo ${arrayZ[@]/%ve/ZZ} # one two three four fiZZ fiZZ
# Поиск ведётся по всем элементам массива

echo ${arrayZ[@]/%o/XX} # one twXX three four five five
# Почему?

echo "-----------------------"
# Before reaching for awk (or anything else)
# Вспомним:
# $( ... ) — вызов функции.
# Функция запускается как подпроцесс.
# Функции выводят на stdout.
# Присваивание производится со stdout функции.
# Запись name[@] — означает операцию "for-each".

newstr() {
echo -n "!!!"
}

echo ${arrayZ[@]/%e/$(newstr)}
# on!!! two thre!!! four fiv!!! fiv!!!
# Q.E.D: Замена — суть есть "присваивание".
# Доступ "For-Each" — ко всем элементам массива
echo ${arrayZ[@]//*/$(newstr optional_arguments)}
# Теперь, если бы Bash просто передал согласованную строку как $0
# к вызываемой функции...
echo

exit 0
</source> 
Подстановка команд может создавать отдельные элементы массива. 
 '''Пример''': '''''Загрузка исходного текста сценария в массив.'''''
<source lang="bash">
#!/bin/bash
# script-array.sh: Сценарий загружает себя в массив.
# Идею подал Chris Martin (спасибо!).

script_contents=( $(cat "$0") ) # Записать содержимое этого сценария ($0)
# в массив.

for element in $(seq 0 $((${#script_contents[@]} - 1)))
do # ${#script_contents[@]}
# даёт число элементов массива.
#
# Вопрос:
# Для чего необходима команда seq 0 ?
# Попробуйте заменить её на seq 1.
echo -n "${script_contents[$element]}"
# Вывести элементы массива в одну строку,
echo -n " — " # разделяя их комбинацией " — " .
done
echo

exit 0

# Упражнение:
# --------
# Попробуйте изменить сценарий таким образом,
# чтобы он выводил себя на экран в первоначальном виде,
# со всеми пробелами, переводами строк и т.п.
</source> 
При работе с массивами, некоторые встроенные команды Bash имеют несколько иной смысл. Например, '''''unset''''' — удаляет отдельные элементы массива, или даже массив целиком. 
 '''Пример''': '''''Некоторые специфичные особенности массивов.'''''
<source lang="bash">
#!/bin/bash
declare -a colors
# Допускается объявление массива без указания его размера.

echo "Введите ваши любимые цвета (разделяя их пробелами)."

read -a colors # Введите хотя бы 3 цвета для демонстрации некоторых свойств массивов.
# Специфический ключ команды 'read',
# позволяющий вводить несколько элементов массива.

echo

element_count=${#colors[@]}

# Получение количества элементов в массиве.
# element_count=${#colors[*]} — даёт тот же результат.
#
# Переменная "@" позволяет "разбивать" строку в кавычках на отдельные слова
# (выделяются слова, разделенные пробелами).

index=0

while [ "$index" -lt "$element_count" ]
do # Список всех элементов в массиве.
echo ${colors[$index]}
let "index = $index + 1"
done
# Каждый элемент массива выводится в отдельной строке.
# Если этого не требуется, то используйте echo -n "${colors[$index]} "
#
# Эквивалентный цикл "for":
# for i in "${colors[@]}"
# do
# echo "$i"
# done
# (Спасибо S.C.)

echo
# Ещё один, более элегантный, способ вывода списка всех элементов массива.
echo ${colors[@]} # ${colors[*]} даёт тот же результат.
echo

# Команда "unset" удаляет элементы из массива, или даже массив целиком.
unset colors[1] # Удаление 2-го элемента массива.
# Тот же эффект даёт команда colors[1]=

echo ${colors[@]} # Список всех элементов массива — 2-й элемент отсутствует.

unset colors # Удаление всего массива.
# Тот же эффект имеют команды unset colors[*]
# и unset colors[@].
echo; echo -n "Массив цветов опустошен."
echo ${colors[@]} # Список элементов массива пуст.

exit 0
</source> 
Как видно из предыдущего примера, обращение к '''''${array_name[@]}''''' или '''''${array_name[*]}''''' относится ко всем элементам массива. Чтобы получить количество элементов массива, можно обратиться к '''''${#array_name[@]}''''' или к '''''${#array_name[*]}'''''. '''''${#array_name}''''' — это длина(количество символов) первого элемента массива, т.е. '''''${array_name[0]}'''''. 
 '''Пример''': '''''Пустые массивы и пустые элементы.'''''
<source lang="bash">
#!/bin/bash
# empty-array.sh
# Выражаю свою благодарность Stephane Chazelas за этот пример,
# и Michael Zick за его доработку.

# Пустой массив — это не то же самое, что массив с пустыми элементами.
array0=( первый второй третий )
array1=( '' ) # "array1" имеет один пустой элемент.
array2=( ) # Массив "array2" не имеет ни одного элемента, т.е. пуст.

echo
ListArray()
{
echo
echo "Элементы массива array0: ${array0[@]}"
echo "Элементы массива array1: ${array1[@]}"
echo "Элементы массива array2: ${array2[@]}"
echo
echo "Длина первого элемента массива array0 = ${#array0}"
echo "Длина первого элемента массива array1 = ${#array1}"
echo "Длина первого элемента массива array2 = ${#array2}"
echo
echo "Число элементов в массиве array0 = ${#array0[*]}" # 3
echo "Число элементов в массиве array1 = ${#array1[*]}" # 1 (сюрприз!)
echo "Число элементов в массиве array2 = ${#array2[*]}" # 0
}

# ===================================================================
ListArray
# Попробуем добавить новые элементы в массивы

# Добавление новых элементов в массивы.
array0=( "${array0[@]}" "новый1" )
array1=( "${array1[@]}" "новый1" )
array2=( "${array2[@]}" "новый1" )

ListArray

# или
array0[${#array0[*]}]="новый2"
array1[${#array1[*]}]="новый2"
array2[${#array2[*]}]="новый2"

ListArray
# Теперь представим каждый массив как 'стек' ('stack')
# Команды выше, можно считать командами 'push' — добавление нового значения на вершину стека
# 'Глубина' стека:
height=${#array2[@]}
echo
echo "Глубина стека array2 = $height"

# Команда 'pop' — выталкивание элемента стека, находящегося на вершине:
unset array2[${#array2[@]}-1] # Индексация массивов начинается с нуля
height=${#array2[@]}
echo
echo "POP"
echo "Глубина стека array2, после выталкивания = $height"

ListArray
# Вывести только 2-й и 3-й элементы массива array0
from=1 # Индексация массивов начинается с нуля
to=2 #
declare -a array3=( ${array0[@]:1:2} )
echo
echo "Элементы массива array3: ${array3[@]}"

# Замена элементов по шаблону
declare -a array4=( ${array0[@]/второй/2-й} )
echo
echo "Элементы массива array4: ${array4[@]}"

# Замена строк по шаблону
declare -a array5=( ${array0[@]//новый?/старый} )
echo
echo "Элементы массива array5: ${array5[@]}"

# Надо лишь привыкнуть к такой записи...
declare -a array6=( ${array0[@]#*новый} )
echo # Это может вас несколько удивить
echo "Элементы массива array6: ${array6[@]}"

declare -a array7=( ${array0[@]#новый1} )
echo # Теперь это вас уже не должно удивлять
echo "Элементы массива array7: ${array7[@]}"

# Выглядит очень похоже на предыдущий вариант...
declare -a array8=( ${array0[@]/новый1/} )
echo
echo "Элементы массива array8: ${array8[@]}"

# Итак, что вы можете сказать обо всем этом?

# Строковые операции выполняются последовательно, над каждым элементом в массиве var[@].
# Таким образом, BASH поддерживает векторные операции
# Если в результате операции получается пустая строка, то элемент массива "исчезает".

# Вопрос: это относится к строкам в "строгих" или "мягких" кавычках?

zap='новый*'
declare -a array9=( ${array0[@]/$zap/} )
echo
echo "Элементы массива array9: ${array9[@]}"

# "...А с платформы говорят: "Это город Ленинград!"..."
declare -a array10=( ${array0[@]#$zap} )
echo
echo "Элементы массива array10: ${array10[@]}"

# Сравните массивы array7 и array10
# Сравните массивы array8 и array9
# Ответ: в "мягких" кавычках.

exit 0
</source> 
Разница между '''''${array_name[@]}''''' и '''''${array_name[*]}''''' такая же, как между $@ и $*. Эти свойства массивов широко применяются на практике. 
<source lang="bash">
# Копирование массивов.
array2=( "${array1[@]}" )
# или
array2="${array1[@]}"

# Добавить элемент.
array=( "${array[@]}" "новый элемент" )
# или
array[${#array[*]}]="новый элемент"
# Спасибо S.C.
</source> 
Операция подстановки команд — '''''array=( element1 element2 ... elementN )''''', позволяет загружать содержимое текстовых файлов в массивы. 
<source lang="bash">
#!/bin/bash
filename=sample_file
# cat sample_file
#
# 1 a b c
# 2 d e fg

declare -a array1array1=( `cat "$filename"`) # Загрузка содержимого файла $filename в массив array1.

# Вывод на stdout.
#
# array1=( `cat "$filename" | tr '\n' ' '`)
# с заменой символов перевода строки на пробелы.
# Впрочем, в этом нет необходимости, поскольку Bash
# выполняет разбивку по словам заменяя символы перевода строки
# на пробелы автоматически.

echo ${array1[@]} # список элементов массива.
# 1 a b c 2 d e fg
#
# Каждое "слово", в текстовом файле, отделяемое от других пробелами
# заносится в отдельный элемент массива.

element_count=${#array1[*]}
echo $element_count # 8
</source> 
 '''Пример''': '''''Инициализация массивов.'''''
<source lang="bash">
#! /bin/bash
# array-assign.bash
# Поскольку здесь рассматриваются операции, специфичные для Bash,
# файл сценария имеет расширение ".bash".
# Copyright (c) Michael S. Zick, 2003, All rights reserved.
# Лицензионное соглашение: Допускается использование сценария# в любом виде без каких либо ограничений.
# Версия: $ID$

# Основан на примере, предоставленном Stephane Chazelas,
# который включен в состав книги: Advanced Bash Scripting Guide.

# Формат вывода команды 'times':
# User CPU <space> System CPU
# User CPU of dead children <space> System CPU of dead children

# Bash предоставляет два способа записи всех элементов
# одного массива в другой.
# В Bash, версий 2.04, 2.05a и 2.05b,
# оба они пропускают 'пустые' элементы
# В более новых версиях добавлена возможность присваивания
# в виде [индекс]=значение.

declare -a bigOne=( /dev/* )
echo
echo 'Условия проверки: Отсутствие кавычек, IFS по-умолчанию, Все-Элементы'
echo "Количество элементов в массиве: ${#bigOne[@]}"

# set -vx
echo
echo '- - проверяется: =( ${array[@]} ) - -'
times
declare -a bigTwo=( ${bigOne[@]} )
# ^ ^
times
echo
echo '- - проверяется: =${array[@]} - -'
times
declare -a bigThree=${bigOne[@]}
# Обратите внимание: круглые скобки отсутствуют.
times
# Сравнение временных показателей свидетельствует о том, что вторая форма записи,
# как заметил Stephane Chazelas, работает в 3-4 раза быстрее.
# Тем не менее, в своих примерах, я буду продолжать использовать первую форму записи
# потому что, на мой взгляд, она более показательна.

# Однако, в отдельных случаях, я буду использовать вторую форму записи,
# с целью увеличения скорости исполнения сценариев.
# MSZ: Прошу прощения, что не предупредил об этом заранее!

exit 0
</source> 
Явное объявление массива с помощью конструкции '''''declare -a''''' может повысить скорость работы с этим массивом в последующих операциях. 
 '''Пример''': '''''Копирование и конкатенация массивов.'''''
<source lang="bash">
#! /bin/bash
# CopyArray.sh
#
# Автор: Michael Zick.
# Используется с его разрешения.

# "Принять из массива с заданным именем записать в массив с заданным именем"
# или "собственный Оператор Присваивания".
CpArray_Mac() {
# Оператор Присваивания
echo -n 'eval '
echo -n "$2" # Имя массива-результата
echo -n '=( ${'
echo -n "$1" # Имя исходного массива
echo -n '[@]} )'
# Все это могло бы быть объединено в одну команду.
# Это лишь вопрос стиля.
}
declare -f CopyArray # "Указатель" на функцию
CopyArray=CpArray_Mac # Оператор Присваивания

Hype()
{
# Исходный массив с именем в $1.
# (Слить с массивом, содержащим "-- Настоящий Рок-н-Ролл".)
# Вернуть результат в массиве с именем $2.
local -a TMP
local -a hype=( -- Настоящий Рок-н-Ролл )

$($CopyArray $1 TMP)
TMP=( ${TMP[@]} ${hype[@]} )
$($CopyArray TMP $2)
}
declare -a before=( Advanced Bash Scripting )
declare -a after

echo "Массив before = ${before[@]}"

Hype before after
echo "Массив after = ${after[@]}"

# Ещё?

echo "Что такое ${after[@]:4:2}?"

declare -a modest=( ${after[@]:2:1} ${after[@]:3:3} )
# ---- выделение подстроки ----

echo "Массив Modest = ${modest[@]}"
# А что в массиве 'before' ?
echo "Массив Before = ${before[@]}"

exit 0
</source> 
 '''Пример''': '''''Ещё пример на конкатенацию массивов.'''''
<source lang="bash">
#! /bin/bash
# array-append.bash
# Copyright (c) Michael S. Zick, 2003, All rights reserved.
# Лицензионное соглашение: Допускается использование сценария
# в любом виде без каких-либо ограничений.
# Версия: $ID$
#
# С небольшими изменениями, внесёнными автором книги.

# Действия над массивами являются специфичными для Bash.
# Эквиваленты в /bin/sh отсутствуют!

# Чтобы избежать скроллинга выводимой информации за пределы терминала,
# передайте вывод от сценария, через конвейер, команде 'more'.
# Упакованный массив.
declare -a array1=( zero1 one1 two1 )
# Разреженный массив (элемент [1] -- не определен).
declare -a array2=( [0]=zero2 [2]=two2 [3]=three2 )

echo
echo '- Проверка того, что массив получился разреженным. -'
echo "Число элементов: 4" # Жёстко "зашито", в демонстрационных целях.
for (( i = 0 ; i < 4 ; i++ ))
do
echo "Элемент [$i]: ${array2[$i]}"
done
# См. так же пример basics-reviewed.bash.

declare -a dest
# Конкатенация двух массивов.
echo
echo 'Условия: Отсутствие кавычек, IFS по-умолчанию, Все-Элементы'
echo '- Неопределённые элементы не передаются. -'
#
# На самом деле неопределенные элементы отсутствуют в массиве.
dest=( ${array1[@]} ${array2[@]} )
# dest=${array1[@]}${array2[@]} # Странный результат, возможно ошибка.

# Теперь выведем результат.
echo
echo '- - Проверка конкатенации массивов - -'
cnt=${#dest[@]}

echo "Число элементов: $cnt"
for (( i = 0 ; i < cnt ; i++ ))
do
echo "Элемент [$i]: ${dest[$i]}"
done
# Записать массив в элемент другого массива (дважды).
dest[0]=${array1[@]}
dest[1]=${array2[@]}

# Вывести результат.
echo
echo '- - Проверка записи содержимого одного массива в элемент другого массива - -'
cnt=${#dest[@]}

echo "Число элементов: $cnt"
for (( i = 0 ; i < cnt ; i++ ))
do
echo "Элемент [$i]: ${dest[$i]}"
done

# Рассмотрение содержимого второго элемента.
echo
echo '- - Запись содержимого второго элемента и вывод результата - -'

declare -a subArray=${dest[1]}
cnt=${#subArray[@]}
echo "Число элементов: $cnt"
for (( i = 0 ; i < cnt ; i++ ))
do
echo "Элемент [$i]: ${subArray[$i]}"
done
# Запись содержимого целого массива в элемент другого массива,
# с помощью конструкции '=${ ... }',
# приводит к преобразованию содержимого первого массива в строку,
# в которой отдельные элементы первого массива разделены пробелом
# (первый символ из переменной IFS).

# If the original elements didn't contain whitespace . . .
# If the original array isn't subscript sparse . . .
# Then we could get the original array structure back again.

# Restore from the modified second element.
echo
echo '- - Listing restored element - -'

declare -a subArray=( ${dest[1]} )
cnt=${#subArray[@]}
echo "Number of elements: $cnt"
for (( i = 0 ; i < cnt ; i++ ))
do
echo "Element [$i]: ${subArray[$i]}"
done
echo '- - Не зависеть от этого поведения. - -'
echo '- - Такое поведение может быть изменено - -'
echo '- - в версиях Bash, более новых, чем версия 2.05b - -'

# MSZ: Прошу прощения за любую раннюю путаницу, ребята.

exit 0
</source> 
Массивы допускают перенос хорошо известных алгоритмов в сценарии на языке командной оболочки. Хорошо ли это — решать вам. 
 '''Пример''': '''''Старая, добрая: "Пузырьковая" сортировка.'''''
<source lang="bash">
#!/bin/bash
# bubble.sh: "Пузырьковая" сортировка.

# На каждом проходе по сортируемому массиву,
# сравниваются два смежных элемента, и, если необходимо, они меняются местами.
# В конце первого прохода, самый "тяжелый" элемент "опускается" в конец массива.
# В конце второго прохода, следующий по "тяжести" элемент занимает второе место снизу.
# И так далее.
# Каждый последующий проход требует на одно сравнение меньше предыдущего.
# Поэтому вы должны заметить ускорение работы сценария на последних проходах.

exchange()
{
# Поменять местами два элемента массива.
local temp=${Countries[$1]} # Временная переменная
Countries[$1]=${Countries[$2]}
Countries[$2]=$temp

return
}

declare -a Countries # Объявление массива,
# необязательно, поскольку он явно инициализируется ниже.
# Допустимо ли выполнять инициализацию массива в нескольких строках?
# ДА!

Countries=(Нидерланды Украина Заир Турция Россия Йемен Сирия \
Бразилия Аргентина Никарагуа Япония Мексика Венесуэла Греция Англия \
Израиль Перу Канада Оман Дания Уэльс Франция Кения \
Занаду Катар Лихтенштейн Венгрия)

# "Занаду" — это мифическое государство, где, согласно Coleridge,
# Kubla Khan построил величественный дворец.

clear # Очистка экрана.

echo "0: ${Countries[*]}" # Список элементов несортированного массива.

number_of_elements=${#Countries[@]}
let "comparisons = $number_of_elements - 1"

count=1 # Номер прохода.

while [ "$comparisons" -gt 0 ] # Начало внешнего цикла
do
index=0 # Сбросить индекс перед началом каждого прохода.
while [ "$index" -lt "$comparisons" ] # Начало внутреннего цикла
do
if [ ${Countries[$index]} \> ${Countries[`expr $index + 1`]} ]
# Если элементы стоят не по порядку...
# Оператор \> выполняет сравнение ASCII-строк
# внутри одиночных квадратных скобок.

# if [[ ${Countries[$index]} > ${Countries[`expr $index + 1`]} ]]
# даёт тот же результат.
then
exchange $index `expr $index + 1` # Поменять местами.
fi
let "index += 1"
done # Конец внутреннего цикла
let "comparisons -= 1" # Поскольку самый "тяжелый" элемент уже "опустился" на дно,
# то на каждом последующем проходе нужно выполнять на одно сравнение меньше.

echo
echo "$count: ${Countries[@]}" # Вывести содержимое массива после каждого прохода.
echo
let "count += 1" # Увеличить счетчик проходов.
done # Конец внешнего цикла

exit 0
</source> 
Можно ли вложить один массив в другой? 
<source lang="bash">
#!/bin/bash
# "Вложенный" массив.

# Автор: Michael Zick.
# незначительные изменения и комментарии добавил William Park.

AnArray=( $(ls --inode --ignore-backups --almost-all \
--directory --full-time --color=none --time=status \
--sort=time -l ${PWD} ) ) # Команды и опции.

# Пробелы важны . . .

SubArray=( ${AnArray[@]:11:1} ${AnArray[@]:6:5} )
# Этот массив содержит шесть элементов:
# SubArray=( [0]=${AnArray[11]} [1]=${AnArray[6]} [2]=${AnArray[7]}
# [3]=${AnArray[8]} [4]=${AnArray[9]} [5]=${AnArray[10]} )
#
# Массивы в Bash оформляются в виде связанных (циклических) списков
# где каждый элемент списка имеет тип string (char *).
# Таким образом, вложенные массивы фактически таковыми не являются,
# хотя функционально очень похожи на них.

echo "Текущий каталог и дата последнего изменения:"
echo "${SubArray[@]}"
exit 0
</source> 
Вложенные массивы, в комбинации с косвенными ссылками, предоставляют в распоряжение программиста ряд замечательных возможностей. 
 '''Пример''': '''''Вложенные массивы и косвенные ссылки.'''''
<source lang="bash">
#!/bin/bash
# embedded-arrays.sh
# Вложенные массивы и косвенные ссылки.

# Автор: Dennis Leeuw.
# Используется с его разрешения.
# Дополнен автором документа.
ARRAY1=(
VAR1_1=value11
VAR1_2=value12
VAR1_3=value13
)

ARRAY2=(
VARIABLE="test"
STRING="VAR1=value1 VAR2=value2 VAR3=value3"
ARRAY21=${ARRAY1[*]}
) # Вложение массива ARRAY1 в массив ARRAY2.

function print () {
OLD_IFS="$IFS"
IFS=$'\n' # Вывод каждого элемента массива в отдельной строке.
TEST1="ARRAY2[*]"
local ${!TEST1} # Посмотрите, что произойдет, если убрать эту строку.
# Косвенная ссылка.
# Позволяет получить доступ к компонентам $TEST1 в этой функции.

# Посмотрим, что получилось.
echo
echo "\$TEST1 = $TEST1" # Просто имя переменной.
echo; echo
echo "{\$TEST1} = ${!TEST1}" # Вывод на экран содержимого переменной.
# Это то, что даёт косвенная ссылка.
echo
echo "-------------------------------------------"; echo
echo

# Вывод переменной
echo "Переменная VARIABLE: $VARIABLE"

# Вывод элементов строки
IFS="$OLD_IFS"
TEST2="STRING[*]"
local ${!TEST2} # Косвенная ссылка (то же, что и выше).
echo "Элемент VAR2: $VAR2 из строки STRING"

# Вывод элемента массива
TEST2="ARRAY21[*]"
local ${!TEST2} # Косвенная ссылка.
echo "Элемент VAR1_1: $VAR1_1 из массива ARRAY21"
}

print
echo

exit 0
</source> 
С помощью массивов, на языке командной оболочки, вполне возможно реализовать алгоритм ''Решета Эратосфена''. Конечно же — это очень ресурсоёмкая задача. В виде сценария она будет работать мучительно долго, так что лучше всего реализовать её на каком-либо другом, компилирующем, языке программирования, таком как C. 
 '''Пример''': '''''Пример реализации алгоритма Решето Эратосфена.'''''
<source lang="bash">
#!/bin/bash
# sieve.sh

# Решето Эратосфена
# Очень старый алгоритм поиска простых чисел.

# Этот сценарий выполняется во много раз медленнее
# чем аналогичная программа на C.

LOWER_LIMIT=1 # Начиная с 1.
UPPER_LIMIT=1000 # До 1000.
# (Вы можете установить верхний предел и выше... если вам есть чем себя занять.)

PRIME=1
NON_PRIME=0
declare -a Primes # Primes[] — массив.

initialize ()
{
# Инициализация массива.
i=$LOWER_LIMIT
until [ "$i" -gt "$UPPER_LIMIT" ]
do
Primes[i]=$PRIME
let "i += 1"
done
# Все числа в заданном диапазоне считать простыми,
# пока не доказано обратное.
}

print_primes ()
{
# Вывод индексов элементов массива Primes[], которые признаны простыми.
i=$LOWER_LIMIT
until [ "$i" -gt "$UPPER_LIMIT" ]
do
if [ "${Primes[i]}" -eq "$PRIME" ]
then
printf "%8d" $i
# 8 пробелов перед числом придают удобочитаемый табличный вывод на экран.
fi

let "i += 1"
done
}

sift () # Отсеивание составных чисел.
{
let i=$LOWER_LIMIT+1
# Нам известно, что 1 — это простое число, поэтому начнем с 2.

until [ "$i" -gt "$UPPER_LIMIT" ]
do
if [ "${Primes[i]}" -eq "$PRIME" ]
# Не следует проверять вторично числа, которые уже признаны составными.
then
t=$i

while [ "$t" -le "$UPPER_LIMIT" ]
do
let "t += $i "
Primes[t]=$NON_PRIME
# Все числа, которые делятся на $t без остатка, пометить как составные.
done
fi
let "i += 1"
done
}

# Вызов функций.
initialize
sift
printprimes

# Это называется структурным программированием.
echo
exit 0
# ----------------------------------------------- #
# Код, приведенный ниже, не исполняется из-за команды exit, стоящей выше.

# Улучшенная версия, предложенная Stephane Chazelas,
# работает несколько быстрее.

# Должен вызываться с аргументом командной строки, определяющем верхний предел.
UPPER_LIMIT=$1 # Из командной строки.
let SPLIT=UPPER_LIMIT/2 # Рассматривать делители только до середины диапазона.

Primes=( '' $(seq $UPPER_LIMIT) )

i=1
until (( ( i += 1 ) > SPLIT )) # Числа из верхней половины диапазона могут не рассматриваться.
do
if [[ -n $Primes[i] ]]
then
t=$i
until (( ( t += i ) > UPPER_LIMIT ))
do
Primes[t]=
done
fi
done
echo ${Primes[*]}
exit 0
</source> 
Сравните этот сценарий с генератором простых чисел, не использующим массивов. Массивы позволяют эмулировать некоторые структуры данных, поддержка которых в Bash не предусмотрена. 
 '''Пример''': '''''Эмуляция структуры "СТЕК" ("первый вошёл — последний вышел").'''''
<source lang="bash">
#!/bin/bash
# stack.sh: Эмуляция структуры "СТЕК" ("первый вошёл — последний вышел")

# Подобно стеку процессора, этот "стек" сохраняет и возвращает данные по принципу
# "первый вошёл — последний вышел".

BP=100 # Базовый указатель на массив-стек.
# Дно стека — 100-й элемент.

SP=$BP # Указатель вершины стека.
# Изначально — стек пуст.

Data= # Содержимое вершины стека.
# Следует использовать дополнительную переменную,
# из-за ограничений на диапазон возвращаемых функциями значений.

declare -a stack

push() # Поместить элемент на вершину стека.
{
if [ -z "$1" ] # А вообще, есть что помещать на стек?
then
return
fi

let "SP -= 1" # Переместить указатель стека.
stack[$SP]=$1

return
}

pop() # Снять элемент с вершины стека.
{
Data= # Очистить переменную.

if [ "$SP" -eq "$BP" ] # Стек пуст?
then
return
fi # Это предохраняет от выхода SP за границу стека — 100,

Data=${stack[$SP]}
let "SP += 1" # Переместить указатель стека.
return
}

status_report() # Вывод вспомогательной информации.
{
echo "-------------------------------------"
echo "ОТЧЁТ"
echo "Указатель стека SP = $SP"
echo "Со стека был снят элемент \""$Data"\""
echo "-------------------------------------"
echo
}

# =======================================================
# А теперь позабавимся.

echo
# Попробуем вытолкнуть что-нибудь из пустого стека.

pop
status_report

echo

push garbage
pop
status_report # Втолкнуть garbage, вытолкнуть garbage.

value1=23; push $value1
value2=skidoo; push $value2
value3=FINAL; push $value3
pop # FINAL
status_report
pop # skidoo
status_report
pop # 23
status_report # Первый вошёл — последний вышел!

# Обратите внимание как изменяется указатель стека на каждом вызове функций push и pop.

echo
# =======================================================
# Упражнения:
# -----------

# 1) Измените функцию "push()" таким образом,
# чтобы она позволяла помещать на стек несколько значений за один вызов.

# 2) Измените функцию "pop()" таким образом,
# чтобы она позволяла снимать со стека несколько значений за один вызов.

# 3) Попробуйте написать простейший калькулятор, выполняющий 4 арифметических действия,
# используя этот пример.
exit 0
</source> 
Иногда, манипуляции с "индексами" массивов могут потребовать введения переменных для хранения промежуточных результатов. В таких случаях вам предоставляется лишний повод подумать о реализации проекта на более мощном языке программирования, например Perl или C. 
 '''Пример''': '''''Исследование математических последовательностей.'''''
<source lang="bash">
#!/bin/bash
# Пресловутая "Q-последовательность" Дугласа Хольфштадтера *Douglas Hofstadter):

# Q(1) = Q(2) = 1
# Q(n) = Q(n - Q(n-1)) + Q(n - Q(n-2)), для n>2
# Это "хаотическая" последовательность целых чисел с непредсказуемым поведением.
# Первые 20 членов последовательности:
# 1 1 2 3 3 4 5 5 6 6 6 8 8 8 10 9 10 11 11 12
# См. книгу Дугласа Хольфштадтера, "Goedel, Escher, Bach: An Eternal Golden Braid",
# p. 137, ff.

LIMIT=100 # Найти первые 100 членов последовательности
LINEWIDTH=20 # Число членов последовательности, выводимых на экран в одной строке
Q[1]=1 # Первые два члена последовательности равны 1.
Q[2]=1

echo
echo "Q-последовательность [первые $LIMIT членов]:"
echo -n "${Q[1]} " # Вывести первые два члена последовательности.
echo -n "${Q[2]} "

for ((n=3; n <= $LIMIT; n++)) # C-подобное оформление цикла.
do # Q[n] = Q[n - Q[n-1]] + Q[n - Q[n-2]] для n>2
# Это выражение необходимо разбить на отдельные действия,
# поскольку Bash не очень хорошо поддерживает сложные арифметические действия над элементами массивов.
let "n1 = $n - 1" # n-1
let "n2 = $n - 2" # n-2

t0=`expr $n - ${Q[n1]}` # n - Q[n-1]
t1=`expr $n - ${Q[n2]}` # n - Q[n-2]

T0=${Q[t0]} # Q[n - Q[n-1]]
T1=${Q[t1]} # Q[n - Q[n-2]]
Q[n]=`expr $T0 + $T1` # Q[n - Q[n-1]] + Q[n - Q[n-2]]
echo -n "${Q[n]} "

if [ `expr $n % $LINEWIDTH` -eq 0 ] # Если выведено очередные 20 членов в строке.
then # то
echo # перейти на новую строку.
fi
done

echo

exit 0

# Этот сценарий реализует итеративный алгоритм поиска членов Q-последовательности.
# Рекурсивную реализацию, как более интуитивно понятную, оставляю вам, в качестве упражнения.
# Внимание: рекурсивный поиск членов последовательности будет занимать *очень* продолжительное время.
</source> 
Bash поддерживает только одномерные массивы, но, путем небольших ухищрений, можно эмулировать многомерные массивы. 
 '''Пример''': '''''Эмуляция массива с двумя измерениями.'''''
<source lang="bash">
#!/bin/bash
# Эмуляция двумерного массива.

# Второе измерение представлено как последовательность строк.
Rows=5
Columns=5

declare -a alpha # char alpha [Rows] [Columns];
# Необязательное объявление массива.

load_alpha ()
{
local rc=0
local index

for i in A B C D E F G H I J K L M N O P Q R S T U V W X Y
do
local row=`expr $rc / $Columns`
local column=`expr $rc % $Rows`
let "index = $row * $Rows + $column"
alpha[$index]=$i # alpha[$row][$column]
let "rc += 1"
done
# Более простой вариант
# declare -a alpha=( A B C D E F G H I J K L M N O P Q R S T U V W X Y )
# но при таком объявлении второе измерение массива завуалировано.
}

print_alpha ()
{
local row=0
local index

echo

while [ "$row" -lt "$Rows" ] # Вывод содержимого массива построчноdo
do
local column=0

while [ "$column" -lt "$Columns" ]
do
let "index = $row * $Rows + $column"
echo -n "${alpha[index]} " # alpha[$row][$column]
let "column += 1"
done

let "row += 1"
echo

done
# Более простой эквивалент:
# echo ${alpha[*]} | xargs -n $Columns

echo
}

filter () # Отфильтровывание отрицательных индексов.
{

echo -n " "

if [[ "$1" -ge 0 && "$1" -lt "$Rows" && "$2" -ge 0 && "$2" -lt "$Columns" ]]
then
let "index = $1 * $Rows + $2"
echo -n " ${alpha[index]}" # alpha[$row][$column]
fi
}

rotate () # Поворот массива на 45 градусов
{
local row
local column

for (( row = Rows; row > -Rows; row-- )) # В обратном порядке.
do
for (( column = 0; column < Columns; column++ ))
do
if [ "$row" -ge 0 ]
then
let "t1 = $column - $row"
let "t2 = $column"
else
let "t1 = $column"
let "t2 = $column + $row"
fi

filter $t1 $t2 # Отфильтровать отрицательный индекс.
done

echo; echo

done
# Поворот массива выполнен на основе примеров (стр. 143-146)
# из книги "Advanced C Programming on the IBM PC", автор Herbert Mayer(см. библиографию).
}

#----------------------------------------------------------------#
load_alpha # Инициализация массива.
print_alpha # Вывод на экран.
rotate # Повернуть на 45 градусов против часовой стрелки.
#----------------------------------------------------------------#

# Упражнения:
# -----------

# 1) Сделайте инициализацию и вывод массива на экран более простым и элегантным способом.
#
# 2) Объясните принцип работы функции rotate().

exit 0
</source> 
По существу, двумерный массив эквивалентен одномерному, с тем лишь различием, что для индексации отдельных элементов используются два ''индекса'' — "'''''строка'''''" и "'''''столбец'''''".

== Файлы ==
'''Сценарии начальной загрузки''' 
Эти файлы содержат объявления псевдонимов и переменных окружения, которые становятся доступны Bash после загрузки и инициализации системы. 
:'''/etc/profile'''
::Настройки системы по-умолчанию, главным образом настраивается окружение командной оболочки (все Bourne-подобные оболочки, не только Bash) 
:'''/etc/bashrc'''
::функции и псевдонимы Bash 
:'''$HOME/.bash_profile'''
::пользовательские настройки окружения Bash, находится в домашнем каталоге у каждого пользователя (локальная копия файла ''/etc/profile'') 
:'''$HOME/.bashrc'''
::пользовательский файл инициализации Bash, находится в домашнем каталоге у каждого пользователя (локальная копия файла ''/etc/bashrc''). 
'''Сценарий выхода из системы (logout)''' 
:'''$HOME/.bash_logout'''
::Этот сценарий отрабатывает, когда пользователь выходит из системы.

== /dev и /proc ==
Как правило, Linux или Unix система имеет каталоги специального назначения: '''/dev''' и '''/proc'''.
=== /dev ===
Каталог ''/dev'' содержит файлы физических устройств, которые могут входить в состав аппаратного обеспечения компьютера. Каждому из разделов не жёстком диске соответствует свой файл-устройство в каталоге ''/dev'', информация о которых может быть получена простой командой [[df]].
<source lang="bash">
bash$ df
Filesystem 1k-blocks Used Available Use% Mounted on
/dev/hda6 495876 222748 2 47527 48% /
/dev/hda1 50755 3887 44248 9% /boot
/dev/hda8 367013 13262 334803 4% /home
/dev/hda5 1714416 1123624 503704 70% /usr
</source> 
Кроме того, каталог ''/dev'' содержит ''loopback''-устройства ("петлевые" устройства), например ''/dev/loop0''. С помощью такого устройства можно представить обычный файл, как блочное устройство ввода/вывода. Это позволяет монтировать целые файловые системы, находящиеся в отдельных больших файлах. 
Отдельные псевдоустройства в ''/dev'' имеют особое назначение, к таким устройствам можно отнести /dev/null, /dev/zero, /dev/urandom и /dev/tcp. 
 '''Пример''': '''''Пример работы с псевдоустройством /dev/tcp.'''''
<source lang="bash">
#!/bin/bash
# dev-tcp.sh: Пример перенаправления на псевдоустройство /dev/tcp

# Автор: Troy Engel.
# Используется с разрешения автора.

TCP_HOST=www.slashdot.org
TCP_PORT=80 # 80-й порт — это стандартный порт службы http.

# Попытка выполнить соединение. (Своего рода 'ping.')
echo "HEAD / HTTP/1.0" >/dev/tcp/${TCP_HOST}/${TCP_PORT}
MYEXIT=$?

: << EXPLANATION
Если bash собран с ключом --enable-net-redirections, то он имеет возможность использовать специальное символьное устройство для перенаправления TCP и UDP.
Оно практически идентично стандартным устройствам STDIN/STDOUT/STDERR.
Создать это устройство (если его ещё нет в системе) можно командой(разумеется, что при этом вы должны обладать правами root):
mknod /dev/tcp c 30 36
>Из руководства к bash:
/dev/tcp/host/port
Если host является верным именем сетевого узла или IP-адресом, а port — целое число
или название сетевой службы, то Bash попытается открыть TCP-соединение с соответствующим узлом.
EXPLANATION

if [ "X$MYEXIT" = "X0" ]; then
echo "Соединение установлено. Код завершения: $MYEXIT"
else
echo "Ошибка при попытке установить соединение. Код завершения: $MYEXIT"
fi

exit $MYEXIT
</source> 
=== /proc ===
Фактически, каталог ''/proc'' — это виртуальная файловая система. Файлы, в каталоге ''/proc'', содержат информацию о процессах, о состоянии и конфигурации ядра и системы.
<source lang="bash">
bash$ cat /proc/devices
Character devices:
1 mem
2 pty
3 ttyp
4 ttyS
5 cua
7 vcs
10 misc
14 sound
29 fb
36 netlink
128 ptm
136 pts
162 raw
254 pcmcia

Block devices:
1 ramdisk
2 fd
3 ide0
9 md

bash$ cat /proc/interrupts
CPU0
0: 84505 XT-PIC timer
1: 3375 XT-PIC keyboard
2: 0 XT-PIC cascade
5: 1 XT-PIC soundblaster
8: 1 XT-PIC rtc
12: 4231 XT-PIC PS/2 Mouse
14: 109373 XT-PIC ide0
NMI: 0
ERR: 0
bash$ cat /proc/partitions
major minor #blocks name rio rmerge rsect ruse wio wmerge wsect wuse running use aveq
3 0 3007872 hda 4472 22260 114520 94240 3551 18703 50384 549710 0 111550 644030
3 1 52416 hda1 27 395 844 960 4 2 14 180 0 800 1140
3 2 1 hda2 0 0 0 0 0 0 0 0 0 0 0
3 4 165280 hda4 10 0 20 210 0 0 0 0 0 210 210
...

bash$ cat /proc/loadavg
0.13 0.42 0.27 2/44 1119
</source> 
Сценарии командной оболочки могут извлекать необходимую информацию из соответствующих файлов в каталоге ''/proc''. 
<source lang="bash">
bash$ cat /proc/filesystems | grep iso9660
iso9660

kernel_version=$( awk '{ print $3 }' /proc/version )

CPU=$( awk '/model name/ {print $4}' < /proc/cpuinfo )
if [ $CPU = Pentium ]
then
выполнить_ряд_специфичных_команд
...
else
выполнить_ряд_других_специфичных_команд
...
fi
</source> 
В каталоге ''/proc'' вы наверняка заметите большое количество подкаталогов, с не совсем обычными именами, состоящими только из цифр. Каждый из них соответствует ''исполняющемуся процессу'', а ''имя'' каталога — это ''ID'' (идентификатор) процесса. Внутри каждого такого подкаталога находится ряд файлов, в которых содержится полезная информация о соответствующих процессах. Файлы ''stat'' и ''status'' хранят статистику работы процесса, ''cmdline'' — команда, которой был запущен процесс, ''exe'' — символическая ссылка на исполняемый файл программы. Здесь же вы найдете ряд других файлов, но, с точки зрения написания сценариев, они не так интересны, как эти четыре. 
 '''Пример''': '''''Поиск файла программы по идентификатору процесса.'''''
<source lang="bash">
#!/bin/bash
# pid-identifier.sh: Возвращает полный путь к исполняемому файлу программы по идентификатору процесса (pid).

ARGNO=1 # Число, ожидаемых из командной строки, аргументов.
E_WRONGARGS=65
E_BADPID=66
E_NOSUCHPROCESS=67
E_NOPERMISSION=68
PROCFILE=exe

if [ $# -ne $ARGNO ]
then
echo "Порядок использования: `basename $0` PID-процесса" >&2 # Сообщение об ошибке на >stderr.
exit $E_WRONGARGS
fi

ps ax

pidno=$( ps ax | grep $1 | awk '{ print $1 }' | grep $1 )
# Проверка наличия процесса с заданным pid в списке, выданном командой "ps", поле #1.
# Затем следует убедиться, что этот процесс не был запущен этим сценарием ('ps').
# Это делает последний "grep $1".

if [ -z "$pidno" ] # Если после фильтрации получается пустая строка,
then # то это означает, что в системе нет процесса с заданным pid.
echo "Нет такого процесса."
exit $E_NOSUCHPROCESS
fi

# Альтернативный вариант:
#if ! ps $1 > /dev/null 2>&1
# then
# в системе нет процесса с заданным pid.
# echo "Нет такого процесса."
# exit $E_NOSUCHPROCESS
# fi

if [ ! -r "/proc/$1/$PROCFILE" ] # Проверить право на чтение.
then
echo "Процесс $1 найден, однако..."
echo "у вас нет права на чтение файла /proc/$1/$PROCFILE."
exit $E_NOPERMISSION # Обычный пользователь не имеет прав
# на доступ к некоторым файлам в каталоге /proc.
fi
# Последние две проверки могут быть заменены на:
# if ! kill -0 $1 > /dev/null 2>&1 # '0' — это не сигнал, но
# команда всё равно проверит наличие
# процесса-получателя.
# then echo "Процесс с данным PID не найден, либо вы не являетесь его владельцем" >&2
# exit $E_BADPID
# fiexe_file=$( ls -l /proc/$1 | grep "exe" | awk '{ print $11 }' )

exe_file=$( ls -l /proc/$1 | grep "exe" | awk '{ print $11 }' )
# Или exe_file=$( ls -l /proc/$1/exe | awk '{print $11}' )
#
#/proc/pid-number/exe — это символическая ссылка
# на исполняемый файл работающей программы.

if [ -e "$exe_file" ] # Если файл /proc/pid-number/exe существует...
then # то существует и соответствующий процесс.
echo "Исполняемый файл процесса #$1: $exe_file."
else
echo "Нет такого процесса."
fi
# В большинстве случаев, этот, довольно сложный сценарий, может быть заменен командой
# ps ax | grep $1 | awk '{ print $5 }'
# В большинстве, но не всегда...
# поскольку пятое поле листинга,выдаваемого командой 'ps', это argv[0] процесса,
# а не путь к исполняемому файлу.
#
# Однако, оба следующих варианта должны работать безотказно.
# find /proc/$1/exe -printf '%l\n'
# lsof -aFn -p $1 -d txt | sed -ne 's/^n//p'

# Автор последнего комментария: Stephane Chazelas.

exit 0
</source> 
 '''Пример''': '''''Проверка состояния соединения.'''''
<source lang="bash">
#!/bin/bash
PROCNAME=pppd # демон ppp
PROCFILENAME=status # Что смотреть.
NOTCONNECTED=65
INTERVAL=2 # Период проверки — раз в 2 секунды.

pidno=$( ps ax | grep -v "ps ax" | grep -v grep | grep $PROCNAME | awk '{ print $1 }' )
# Найти идентификатор процесса 'pppd', 'ppp daemon'.
# По пути убрать из листинга записи о процессах, порожденных сценарием.
#
# Однако, как отмечает Oleg Philon,
# Эта последовательность команд может быть заменена командой "pidof".
# pidno=$( pidof $PROCNAME )
#
# Мораль:
# Когда последовательность команд становится слишком сложной,
# это повод к тому, чтобы поискать более короткий вариант.

if [ -z "$pidno" ] # Если получилась пустая строка, значит процесс не запущен.
then
echo "Соединение не установлено."
exit $NOTCONNECTED
else
echo "Соединение установлено."; echo
fi

while [ true ] # Бесконечный цикл.
do
if [ ! -e "/proc/$pidno/$PROCFILENAME" ]
# Пока работает процесс, файл "status" существует.
then
echo "Соединение разорвано."
exit $NOTCONNECTED
fi
netstat -s | grep "packets received" # Получить некоторые сведения о соединении.
netstat -s | grep "packets delivered"

sleep $INTERVAL
echo; echo
done

exit 0
# Как обычно, этот сценарий может быть остановлен комбинацией клавиш Control-C.

# Упражнение:
# ----------
# Добавьте возможность завершения работы сценария, по нажатии на клавишу "q".
# Это сделает скрипт более дружественным к пользователю.
</source> 
Будьте предельно осторожны при работе с файловой системой ''/proc'', так как попытка записи в некоторые файлы может повредить файловую систему или привести к краху системы.

== /dev/zero и /dev/null ==
''/dev/null'' 
:Псевдоустройство ''/dev/null'' — это, своего рода, "чёрная дыра" в системе. Это, пожалуй, самый близкий смысловой эквивалент. Всё, что записывается в этот файл, "исчезает" навсегда. Попытки записи или чтения из этого файла не дают, ровным счётом, никакого результата. Тем не менее, псевдоустройство ''/dev/null'' вполне может пригодиться.<>
:
'''Подавление вывода на stdout.''' 
<source lang="bash">
cat $filename >/dev/null
# Содержимое файла $filename не появится на stdout.
</source> 

'''Подавление вывода на stderr.''' 
<source lang="bash">
rm $badname 2>/dev/null
# Сообщение об ошибке "уйдёт в никуда".
</source> 

'''Подавление вывода, как на stdout, так и на stderr.''' 
<source lang="bash">
cat $filename 2>/dev/null >/dev/null
# Если "$filename" не будет найден, то вы не увидите сообщения об ошибке.
# Если "$filename" существует, то вы не увидите его содержимое.
# Таким образом, вышеприведённая команда ничего не выводит на экран.
#
# Такая методика бывает полезной, когда необходимо лишь проверить код завершения команды
# и нежелательно выводить результат работы команды на экран.
#
#cat $filename &>/dev/null
# даёт тот же результат, автор примечания Baris Cicek.
</source> 
'''Удаление содержимого файла, сохраняя, при этом, сам файл, со всеми его правами доступа(очистка файла)''' 
<source lang="bash">
cat /dev/null > /var/log/messages
# : > /var/log/messages дает тот же эффект, но не порождает дочерний процесс.

cat /dev/null > /var/log/wtmp
</source> 
Автоматическая очистка содержимого системного журнала (logfile) (особенно хороша для борьбы с надоедливыми рекламными идентификационными файлами ("cookies")): 
 '''Пример''': '''''Удаление cookie-файлов.'''''
<source lang="bash">
if [ -f ~/.netscape/cookies ] # Удалить, если имеются.
then
rm -f ~/.netscape/cookies
fi
ln -s /dev/null ~/.netscape/cookies
# Теперь, все cookie-файлы, вместо того, чтобы сохраняться на диске, будут "вылетать в трубу".
</source> 

''/dev/zero''
Подобно псевдоустройству ''/dev/null'', ''/dev/zero'' так же является псевдоустройством, с той лишь разницей, что содержит нули (здесь имеются ввиду двоичные нули, а не символы "0" ASCII). Информация, выводимая в этот файл, так же бесследно исчезает. Чтение нулей из этого файла может вызвать некоторые затруднения, однако это можно сделать, к примеру, с помощью команды '''''od''''' или шестнадцатиричного редактора. В основном, ''/dev/zero'' используется для создания заготовки файла с заданой длиной. 
 '''Пример''': '''''Создание файла подкачки (swapfile), с помощью /dev/zero.'''''
<source lang="bash">
#!/bin/bash

# Создание файла подкачки.
# Этот сценарий должен запускаться с правами root.
ROOT_UID=0 # Для root — $UID 0.
E_WRONG_USER=65 # Не root?

FILE=/swap
BLOCKSIZE=1024
MINBLOCKS=40
SUCCESS=0
if [ "$UID" -ne "$ROOT_UID" ]
then
echo; echo "Этот сценарий должен запускаться с правами root."; echo
exit $E_WRONG_USER
fi
blocks=${1:-$MINBLOCKS} # По-умолчанию — 40 блоков, если размер не задан из командной строки.
# Ниже приводится эквивалентный набор команд.
# --------------------------------------------------
# if [ -n "$1" ]
# then
# blocks=$1
# else
# blocks=$MINBLOCKS
# fi
# --------------------------------------------------

if [ "$blocks" -lt $MINBLOCKS ]
then
blocks=$MINBLOCKS # Должно быть как минимум 40 блоков.
fi

echo "Создание файла подкачки размером $blocks блоков (KB)."
dd if=/dev/zero of=$FILE bs=$BLOCKSIZE count=$blocks # "Забить" нулями.

mkswap $FILE $blocks # Назначить как файл подкачки.
swapon $FILE # Активировать.

echo "Файл подкачки создан и активирован."

exit $SUCCESS
</source> 
Ещё одна область применения ''/dev/zero'' — "очистка" специального файла заданного размера, например файлов, монтируемых как ''loopback''-устройства или для безопасного удаления файла. 
 '''Пример''': '''''Создание электронного диска.'''''
<source lang="bash">
#!/bin/bash
# ramdisk.sh
# "электронный диск" — это область в ОЗУ компьютера с которой система взаимодействует как с файловой системой.
# Основное преимущество — очень высокая скорость чтения/записи.
# Недостатки — энергозависимость, уменьшение объема ОЗУ, доступного системе, относительно небольшой размер.
#
# Чем хорош электронный диск?
# При хранении наборов данных, таких как таблиц баз данных или словарей, на электронном диске вы получаете высокую скорость работы с этими наборами, поскольку время доступа к ОЗУ
# неизмеримо меньше времени доступа к жёсткому диску.

E_NON_ROOT_USER=70 # Сценарий должен запускаться с правами root.
ROOTUSER_NAME=root
MOUNTPT=/mnt/ramdisk
SIZE=2000 # 2K блоков (измените, если это необходимо)
BLOCKSIZE=1024 # размер блока — 1K (1024 байт)
DEVICE=/dev/ram0 # Первое устройство ram

username=`id -nu`
if [ "$username" != "$ROOTUSER_NAME" ]
then
echo "Сценарий должен запускаться с правами root."
exit $E_NON_ROOT_USER
fi

if [ ! -d "$MOUNTPT" ] # Проверка наличия точки монтирования,
then # благодаря этой проверке, при повторных запусках сценария
mkdir $MOUNTPT # ошибки возникать не будет.
fi

dd if=/dev/zero of=$DEVICE count=$SIZE bs=$BLOCKSIZE # Очистить электронный диск.
mke2fs $DEVICE # Создать файловую систему ext2.
mount $DEVICE $MOUNTPT # Смонтировать.
chmod 777 $MOUNTPT # Сделать электронный диск доступным для обычных пользователей. Но при этом, только root сможет его отмонтировать.

echo "Электронный диск \"$MOUNTPT\" готов к работе."

# Теперь электронный диск доступен для любого пользователя в системе.
# Внимание! Электронный диск — это энергозависимое устройство! Все данные, хранящиеся на нём,
# будут утеряны при остановке или перезагрузке системы.
# Если эти данные представляют для вас интерес, то сохраняйте их копии в обычном каталоге.
# После перезагрузки, чтобы вновь создать электронный диск, запустите этот сценарий.
# Простое монтирование /mnt/ramdisk, без выполнения подготовительных действий, не будет работать.

exit 0
</source> 

== Отладка сценариев ==
Командная оболочка Bash не имеет своего отладчика, и не имеет даже каких либо отладочных команд или конструкций. Синтаксические ошибки или опечатки часто вызывают сообщения об ошибках, которые которые практически никак не помогают при отладке. 
 '''Пример''': '''''Сценарий, содержащий ошибку.'''''
<source lang="bash">
#!/bin/bash
# ex74.sh
# Этот сценарий содержит ошибку.
a=37
if [$a -gt 27 ]
then
echo $a
fi
exit 0
</source> 
В результате исполнения этого сценария вы получите такое сообщение:
<source lang="bash">
./ex74.sh: [37: command not found
</source> 
Что в этом сценарии может быть неправильно (подсказка: после ключевого слова '''if'''?)
 '''Пример''': '''''Пропущено ключевое слово.'''''
<source lang="bash">
#!/bin/bash
# missing-keyword.sh:
# Какое сообщение об ошибке будет выведено, при попытке запустить этот сценарий?
for a in 1 2 3
do
echo "$a"
# done # Необходимое ключевое слово 'done' закомментировано.
exit 0
</source> 
На экране появится сообщение: 
<source lang="bash">
missing-keyword.sh: line 11: syntax error: unexpected end of file
</source> 
Обратите внимание, сообщение об ошибке будет содержать номер не той строки, в которой возникла ошибка, а той, в которой Bash точно установил наличие ошибочной ситуации. Сообщения об ошибках могут вообще не содержать номера строки, при исполнении которой эта ошибка появилась. А что делать, если сценарий работает, но не так как ожидалось? Вот пример весьма распространенной логической ошибки. 
 '''Пример''': '''''test24.'''''
<source lang="bash">
#!/bin/bash
# Ожидается, что этот сценарий будет удалять в текущем каталоге
# все файлы, имена которых содержат пробелы.
# Но он не работает. Почему?

badname=`ls | grep ' '`

# echo "$badname"
rm "$badname"
exit 0
</source> 
Попробуйте найти ошибку, раскомментировав строку '''echo "$badname"'''. Инструкция [[echo]] очень полезна при отладке сценариев, она позволяет узнать — действительно ли вы получаете то, что ожидали получить.
В данном конкретном случае, команда '''rm "$badname"''' не даёт желаемого результата потому, что переменная ''$badname'' взята в кавычки. В результате, [[rm]] получает единственный аргумент (т.е. команда будет считать, что получила имя одного файла). Частично эта проблема может быть решена за счёт удаления кавычек вокруг ''$badname'' и установки переменной $IFS так, чтобы она содержала только символ перевода строки, '''''IFS=$'\n' '''''. Однако, существует более простой способ выполнить эту задачу. 
<source lang="bash">
# Правильный способ удаления файлов, в чьих именах содержатся пробелы.
rm *\ *
rm *" "*
rm *' '*
# Спасибо S.C.
</source> 
В общих чертах, ошибочными можно считать такие сценарии, которые: 
# "сыплют" сообщениями о "синтаксических ошибках" или
# запускаются, но работают не так как ожидалось (логические ошибки).
# запускаются, делают то, что требуется, но имеют побочные эффекты (логическая бомба). 
Инструменты, которые могут помочь при отладке неработающих сценариев:
:1. команда [[echo]], в критических точках сценария, поможет отследить состояние переменных и отобразить ход исполнения.
:2. команда-фильтр [[tee]], которая поможет проверить процессы и потоки данных в критических местах.
:3. ключи ''-n -v -x''
:'''''sh -n scriptname''''' — проверит наличие синтаксических ошибок, не запуская сам сценарий. Того же эффекта можно добиться, вставив в сценарий команду '''''set -n''''' или '''''set -o noexec'''''. Обратите внимание, некоторые из синтаксических ошибок не могут быть выявлены таким способом.
:'''''sh -v scriptname''''' — выводит каждую команду прежде, чем она будет выполнена. Того же эффекта можно добиться, вставив в сценарий команду '''''set -v''''' или '''''set -o verbose'''''.
:Ключи ''-n'' и ''-v'' могут употребляться совместно: '''''sh -nv scriptname'''''.
:'''''sh -x scriptname''''' — выводит, в краткой форме, результат исполнения каждой команды. Того же эффекта можно добиться, вставив в сценарий команду '''''set -x''''' или '''''set -o xtrace'''''.
:Вставив в сценарий '''''set -u''''' или '''''set -o nounset''''', вы будете получать сообщение об ошибке ''unbound variable'' всякий раз, когда будет производиться попытка обращения к необъявленной переменной.
:4. Функция "assert", предназначенная для проверки переменных или условий, в критических точках сценария. (Эта идея заимствована из языка программирования C.)
 '''Пример''': '''''Проверка условия с помощью функции "assert".'''''
<source lang="bash">
#!/bin/bash
# assert.sh

assert () # Если условие ложно,
{ # выход из сценария с сообщением об ошибке.
E_PARAM_ERR=98
E_ASSERT_FAILED=99

if [ -z "$2" ] # Недостаточное количество входных параметров.
then
return $E_PARAM_ERR
fi

lineno=$2

if [ ! $1 ]
then
echo "Утверждение ложно: \"$1\""
echo "Файл: \"$0\", строка: $lineno"
exit $E_ASSERT_FAILED
# else
# return
# и продолжить исполнение сценария.
fi
}

a=5
b=4
condition="$a -lt $b" # Сообщение об ошибке и завершение сценария.
# Попробуйте поменять условие "condition"
# на что-нибудь другое и посмотреть что получится.
assert "$condition" $LINENO
# Сценарий продолжит работу только в том случае, если утверждение истинно.
# Прочие команды.
# ...

echo "Эта строка появится на экране только если утверждение истинно."
# ...
# Прочие команды.
# ...

exit 0
</source> 
:5. Ловушка на выход в этом сценарии может быть неправильна (подсказка: после ключевого слова). 
Команда '''''exit''''', в сценарии, порождает сигнал '''0''', по которому процесс завершает работу, т.е. — сам сценарий. Часто бывает полезным по выходу из сценария выдать "распечатку" переменных. 
'''Установка ловушек на сигналы''' 
'''trap''' 
Определяет действие при получении сигнала; так же полезна при отладке. 
''Сигнал (signal)'' — это просто сообщение, передаётся процессу либо ядром, либо другим процессом, чтобы побудить процесс выполнить какие-либо действия(обычно — завершить работу). Например, нажатие на ''Control-C'', вызывает передачу сигнала ''SIGINT'', исполняющейся программе.
<source lang="bash">
trap '' 2
# Игнорировать прерывание 2 (Control-C), действие по сигналу не указано.
trap 'echo "Control-C disabled."' 2
# Сообщение при нажатии на Control-C.
</source> 
 '''Пример''': '''''Ловушка на выходе.'''''
<source lang="bash">
#!/bin/bash
trap 'echo Список переменных — a = $a b = $b' EXIT
# EXIT — это название сигнала, генерируемого при выходе из сценария.

a=39
b=36
exit 0
# Примечательно, что если закомментировать команду 'exit',
# то это никак не скажется на работе сценария,
# поскольку "выход" из сценария происходит в любом случае.
</source> 
 '''Пример''': '''''Удаление временного файла при нажатии на Control-C.'''''
<source lang="bash">
#!/bin/bash
# logon.sh: Сценарий, написанный "на скорую руку", контролирует вход в режим on-line.

TRUE=1
LOGFILE=/var/log/messages
# Обратите внимание: $LOGFILE должен быть доступен на чтение (chmod 644 /var/log/messages).
TEMPFILE=temp.$$
# "Уникальное" имя для временного файла, где расширение в имени -- это pid процесса-сценария.
KEYWORD=address
# При входе, в файл /var/log/messages,
# добавляется строка "remote IP address xxx.xxx.xxx.xxx"

ONLINE=22
USER_INTERRUPT=13
CHECK_LINES=100
# Количество проверяемых строк.

trap 'rm -f $TEMPFILE; exit $USER_INTERRUPT' TERM INT
# Удалить временный файл, когда сценарий завершает работу по control-c.

echo

while [ $TRUE ] #Бесконечный цикл.
do
tail -$CHECK_LINES $LOGFILE> $TEMPFILE
# Последние 100 строк из системного журнала переписать во временный файл.
# Совершенно необходимо, т.к. новейшие версии ядер генерируют много сообщений при входе.
search=`grep $KEYWORD $TEMPFILE`
# Проверить наличие фразы "address",
# свидетельствующей об успешном входе.
if [ ! -z "$search" ] # Кавычки необходимы, т.к. переменная может содержать пробелы.
then
echo "On-line"
rm -f $TEMPFILE # Удалить временный файл.
exit $ONLINE
else
echo -n "." # ключ -n подавляет вывод символа перевода строки,
# так вы получите непрерывную строку точек.
fi

sleep 1
done
# Обратите внимание: если изменить содержимое переменной KEYWORD
# на "Exit", то сценарий может использоваться для контроля
# неожиданного выхода (logoff).

exit 0
# Nick Drage предложил альтернативный метод:
while true
do ifconfig ppp0 | grep UP 1> /dev/null && echo "соединение установлено" && exit 0
echo -n "." # Печать последовательности точек (.....), пока соединение не будет установлено.
sleep 2
done
# Проблема: Нажатия Control-C может оказаться недостаточным, чтобы завершить этот процесс.
# (Точки продолжают выводиться на экран.)
# Упражнение: Исправьте этот недостаток.

# Stephane Chazelas предложил ещё одну альтернативу:
CHECK_INTERVAL=1

while ! tail -1 "$LOGFILE" | grep -q "$KEYWORD"
do echo -n .
sleep $CHECK_INTERVAL
done
echo "On-line"
# Упражнение: Найдите сильные и слабые стороны
# каждого из этих подходов.
</source> 
Аргумент ''DEBUG'', команды '''''trap''''', заставляет сценарий выполнять указанное действие после выполнения каждой команды. Это можно использовать для трассировки переменных.
 '''Пример''': '''''Трассировка переменной.'''''
<source lang="bash">
#!/bin/bash
trap 'echo "VARIABLE-TRACE> $LINENO: \$variable = \"$variable\""' DEBUG
# Выводить значение переменной после исполнения каждой команды.

variable=29
echo "Переменная \"\$variable\" инициализирована числом $variable."

let "variable *= 3"
echo "Значение переменной \"\$variable\" увеличено в 3 раза."

# Конструкция "trap 'commands' DEBUG" может оказаться очень полезной
# при отладке больших и сложных скриптов,
# когда размещение множества инструкций "echo $variable"
# может потребовать достаточно большого времени.
# Спасибо Stephane Chazelas.

exit 0
</source> 
Конструкция ''trap'' ' ' ''SIGNAL'' (две одиночных кавычки) — запрещает ''SIGNAL'' для оставшейся части сценария. Конструкция ''trap SIGNAL'' — восстанавливает действие сигнала ''SIGNAL''. Эти конструкции могут использоваться для защиты критических участков сценария от нежелательного прерывания.
<source lang="bash">
trap '' 2 # Сигнал 2 (Control-C) — запрещён.
command
command
command
trap 2 # Разрешение реакции на Control-C
</source> 

== Необязательные параметры(ключи) ==
'''Необязательные параметры''' — это дополнительные ключи (''опции''), которые оказывают влияние на поведение сценария и/или командной оболочки. Команда '''''set''''' позволяет задавать дополнительные опции прямо внутри сценария. В том месте сценария, где необходимо, чтобы та или иная опция вступила в силу, вставьте такую конструкцию '''''set -o option-name''''', или в более короткой форме — '''''set -option-abbrev'''''. Эти две формы записи совершенно идентичны по своему действию. 
<source lang="bash">
#!/bin/bash

set -o verbose
# Вывод команд перед их исполнением.
</source> 
<source lang="bash">
#!/bin/bash

set -v
# Имеет тот же эффект, что и выше.
</source> 
Для того, чтобы отключить действие той или иной опции, следует вставить конструкцию '''''set +ooption-name''''', или '''''set +option-abbrev'''''.
<source lang="bash">
#!/bin/bash

set -o verbose
# Вывод команд перед их исполнением.
command
...
command

set +o verbose
Запретить вывод команд перед их исполнением.
command
# команда не выводится.

set -v
# Вывод команд перед их исполнением.
command
...
command

set +v
# Запретить вывод команд перед их исполнением.
command

exit 0
</source> 
Как вариант установки опций, можно предложить указывать их в заголовке сценария (в строке sha-bang) — '''#!'''.
<source lang="bash">
#!/bin/bash -x
#
# Далее следует текст сценария.
</source> 
Так же можно указывать дополнительные ключи в командной строке, при запуске сценария. Некоторые из опций работают только если они заданы из командной строки, например ''-i'' — ключ интерактивного режима работы скрипта.
<source lang="bash">
bash -v script-name

bash -o verbose script-name
</source> 
Ниже приводится список некоторых полезных опций, которые могут быть указаны как в полной форме (полная форма ключа начинается с двойного дефиса) так и в сокращенной (краткая форма ключа начинается с одинарного дефиса). 
''Таблица'' '''''Ключи Bash'''''
{| class="wikitable"
|-
! Краткое имя !! Полное имя !! Описание
|-
| '''-C''' || noclobber || Предотвращает перезапись файла в операциях перенаправления вывода (не распространяется на конвейеры (каналы) <nowiki>-->|</nowiki>)
|-
| '''-D''' || (нет) || Выводит список строк в двойных кавычках, которым предшествует символ $, сам сценарий не исполняется
|-
| '''-a''' || allexport || Экспорт всех, определенных в сценарии, переменных
|-
| '''-b''' || notify || Выводит уведомление по завершении фоновой задачи (job) (довольно редко используется в сценариях)
|-
| '''-c ...''' || (нет) || Читает команды из ...
|-
| '''-e''' || errexit || Прерывает исполнения сценария при появлении первой же ошибки, т.е. когда встретится команда, которая
вернёт ненулевой код возврата(за исключением циклов until или while, оператора if, цепочек из команд)
|-
| '''-f''' || noglob || Подстановка имён файлов(globbing) запрещена
|-
| '''-i''' || interactive || Сценарий запускается в интерактивном режиме
|-
| '''-n''' || noexec || Команды в сценарии считываются, но не исполняются(проверка синтаксиса)
|-
| '''-o Option-Name''' || (нет) || Установка опции Option-Name option
|-
| '''-o posix''' || POSIX || Изменяет поведение Bash или сценария таким образом, чтобы оно соответствовало стандарту POSIX.
|-
| '''-p''' || privileged || Сценарий запускается как "suid"(осторожно!)
|-
| '''-r''' || restricted || Сценарий запускается в ограниченном режиме
|-
| '''-s''' || stdin || Читает команды с устройства стандартного ввода ''stdin''
|-
| '''-t''' || (нет) || Завершает работу после выполнения первой команды
|-
| '''-u''' || nounset || При попытке обращения к неопределённым переменным, выдаёт сообщение об
ошибке и прерывает работу сценария
|-
| '''-v''' || verbose || Выводит на ''stdout'' каждую команду прежде, чем она будет исполнена
|-
| '''-x''' || xtrace || Подобна ''-v'', но выполняет подстановку команд
|-
| '''-''' || (нет) || Конец списка ключей(опций), последующие аргументы будут восприниматься как позиционные параметры.
|-
| '''--''' || (нет) || Эквивалент предыдущей опции(-).
|-
|}

== Широко распространённые ошибки ==
:::::::::::::::::::::::::::::::::::::::::::::'''Turandot''': ''Gli enigmi sono tre, la morte una!''
:::::::::::::::::::::::::::::::::::::::::::::'''Caleph''': ''No, no! Gli enigmi sono tre, una la vita!''
::::::::::::::::::::::::::::::::::::::::::::::::::::::::'''''Puccini''''' 
Использование зарезервированных слов и служебных символов в качестве имён переменных.
<source lang="bash">
case=value0 # Может вызвать проблемы.
23skidoo=value1 # Тоже самое.
# Имена переменных, начинающиеся с цифр, зарезервированы командной оболочкой.
# Если имя переменной начинается с символа подчеркивания: _23skidoo=value1, то это не считается ошибкой.
# Однако... если имя переменной состоит из единственного символа подчеркивания, то это ошибка.
_=25
echo $_ # $_ — это внутренняя переменная.
xyz((!*=value2 # Вызывает серьезные проблемы.
</source> 
Использование дефиса, и других зарезервированных символов, в именах переменных.
<source lang="bash">
var-1=23
# Вместо такой записи используйте 'var_1'.
</source> 
Использование одинаковых имён для переменных и функций. Это делает сценарий трудным для понимания.
<source lang="bash">
do_something ()
{
echo "Эта функция должна что-нибудь сделать с \"$1\"."
}
do_something=do_something
do_something do_something
# Всё это будет работать правильно, но слишком уж запутанно.
</source> 
Использование лишних пробелов. В отличие от других языков программирования, Bash весьма привередлив по отношению к пробелам.
<source lang="bash">
var1 = 23 # Правильный вариант: 'var1=23'.
# В вышеприведенной строке Bash будет трактовать "var1" как имя команды с аргументами "=" и "23".

let c = $a - $b # Правильный вариант: 'let c=$a-$b' или 'let "c = $a - $b"'

if [ $a -le 5] # Правильный вариант: if [ $a -le 5 ]
# if [ "$a" -le 5 ] ещё лучше.
# [[ $a -le 5 ]] тоже верно.
</source> 
Ошибочным является предположение о том, что неинициализированные переменные содержат "'''ноль'''". Неинициализированные переменные содержат "пустое" ('''null''') значение, а не '''ноль'''.
<source lang="bash">
#!/bin/bash
echo "uninitialized_var = $uninitialized_var"
# uninitialized_var =
</source> 
Часто программисты путают операторы сравнения '''=''' и '''-eq'''. Запомните, оператор '''=''' используется для сравнения строковых переменных, а '''-eq''' — для сравнения целых чисел.
<source lang="bash">
if [ "$a" = 273 ] # Как вы полагаете? $a — это целое число или строка?
if [ "$a" -eq 273 ] # Если $a — целое число.

# Иногда, такого рода ошибка никак себя не проявляет.
# Однако...

a=273.0 # Не целое число.

if [ "$a" = 273 ]
then
echo "Равны."
else
echo "Не равны."
fi # Не равны.

# тоже самое и для a=" 273" и a="0273".

# Подобные проблемы возникают при использовании "-eq" со строковыми значениями.

if [ "$a" -eq 273.0 ]
then
echo "a = $a'
fi # Исполнение сценария прерывается по ошибке.
# test.sh: [: 273.0: integer expression expected
</source> 
Ошибки при сравнении целых чисел и строковых значений.
 '''Пример''': '''''Строки и числа нельзя сравнивать напрямую.'''''
<source lang="bash">
#!/bin/bash
# bad-op.sh: Попытка строкового сравнения для целых чисел.

echo
number=1
# Следующий цикл "while" порождает две ошибки:
# одна обнаруживается сразу, другая не так очевидна.

while [ "$number" < 5 ] # Ошибка! Должно быть: while [ "$number" -lt 5 ]
do
echo -n "$number "
let "number += 1"
done
# При попытке запустить этот сценарий на терминал выводится сообщение:
# bad-op.sh: line 10: 5: No such file or directory
# Внутри одиночных квадратных скобок, символ "<" должен экранироваться,
# но даже если соблюсти синтаксис, то результат сравнения все равно будет неверным.
echo "---------------------"
while [ "$number" \< 5 ] # 1 2 3 4
do #
echo -n "$number " # Здесь вроде бы нет ошибки, но . . .
let "number += 1" # фактически выполняется сравнение строк,
done # а не чисел.

echo; echo "---------------------"
# Это может породить определённые проблемы, например:

lesser=5
greater=105

if [ "$greater" \< "$lesser" ]
then
echo "число $greater меньше чем число $lesser"
fi # число 105 меньше чем число 5
# И действительно! Строка "105" меньше чем строка "5"!
# (при выполнении сравнения ASCII кодов).

echo
exit 0
</source> 
Иногда, в операциях проверки, с использованием квадратных скобок ('''[ ]'''), переменные необходимо брать в двойные кавычки('''" "'''). 
Иногда сценарий не в состоянии выполнить команду из-за нехватки прав доступа. Если пользователь не сможет запустить команду из командной строки, то эта команда не сможет быть запущена и из сценария. Попробуйте изменить атрибуты команды, возможно вам придется установить бит ''suid''. 
Использование символа '''-''' в качестве оператора перенаправления (каковым он не является) может приводить к неожиданным результатам.
<source lang="bash">
command1 2> - | command2 # Попытка передать сообщения об ошибках команде command1 через конвейер...
# ...не будет работать.
command1 2>& - | command2 # Так же бессмысленно.
#Спасибо S.C.
</source> 
Использование функциональных особенностей Bash версии 2 или выше, может привести к аварийному завершению сценария, работающему под управлением Bash версии 1.XX.
<source lang="bash">
#!/bin/bash

minimum_version=2# Поскольку Chet Ramey постоянно развивает Bash,
# вам может потребоваться указать другую минимально допустимую версию $minimum_version=2.XX.
E_BAD_VERSION=80

if [ "$BASH_VERSION" \< "$minimum_version" ]
then
echo "Этот сценарий должен исполняться под управлением Bash, версии $minimum или выше."
echo "Настоятельно рекомендуется обновиться."
exit $E_BAD_VERSION
fi
...
</source> 
Использование специфических особенностей Bash может приводить к аварийному завершению сценария в Bourne shell (#!/bin/sh). Как правило, в дистрибутивах Linux, sh является псевдонимом bash, но это не всегда верно для Unix-систем в целом. Использование недокументированных возможностей Bash весьма небезопасная практика. Предыдущие версии этой книги включали в себя ряд сценариев , которые использовали такие "возможности", например — возможность возвращать через ''exit'' или ''return'' большие (по абсолютному значению) отрицательные целые числа. К сожалению, в версии 2.05b и более поздних, эта "лазейка" была закрыта. \
Сценарий, в котором строки отделяются друг от друга в стиле MS-DOS (''\r\n''), будет завершаться аварийно, поскольку комбинация #!/bin/bash\r\n считается недопустимой. Исправить эту ошибку можно простым удалением символа ''\r'' из сценария.
<source lang="bash">
#!/bin/bash
echo "Начало"

unix2dos $0 # Сценарий переводит символы перевода строки в формат DOS.
chmod 755 $0 # Восстановление прав на запуск.
# Команда 'unix2dos' удалит право на запуск из атрибутов файла.

./$0 # Попытка запустить себя самого.
# Но это не сработает из-за того, что теперь строки отделяются друг от друга в стиле DOS.

echo "Конец"
exit 0
</source> 
'''''Сценарий, начинающийся с #!/bin/sh, не может работать в режиме полной совместимости с Bash'''''. Некоторые из специфических функций, присущих Bash, могут оказаться запрещёнными к использованию. '''''Сценарий, который требует полного доступа ко всем расширениям, имеющимся в Bash, должен начинаться строкой #!/bin/bash'''''. 
"Лишние" пробелы перед строкой-ограничителем, завершающей встроенный документ, будут приводить к ошибкам в работе сценария. 
Сценарий не может экспортировать переменные родительскому процессу — оболочке. Здесь как в природе, потомок может унаследовать черты родителя, но не наоборот.
<source lang="bash">
WHATEVER=/home/bozo
export WHATEVER
exit 0

bash$ echo $WHATEVER
bash$
</source> 
Будьте уверены — при выходе в командную строку переменная $WHATEVER останется неинициализированной. Использование в подоболочке переменных с теми же именами, что и в родительской оболочке может не давать ожидаемого результата.
 '''Пример''': '''''Западня в подоболочке.'''''
<source lang="bash">
#!/bin/bash
# Западня в подоболочке.

outer_variable=внешняя_переменная
echo
echo "outer_variable = $outer_variable"
echo

(
# Запуск в подоболочке

echo "внутри подоболочки outer_variable = $outer_variable"
inner_variable=внутренняя_переменная
# Инициализировать
echo "внутри подоболочки inner_variable = $inner_variable"
outer_variable=внутренняя_переменная # Как думаете? Изменит внешнюю переменную?
echo "внутри подоболочки outer_variable = $outer_variable"

# Выход из подоболочки
)

echo
echo "за пределами подоболочки inner_variable = $inner_variable" # Ничего не выводится.
echo "за пределами подоболочки outer_variable = $outer_variable" # внешняя_переменная.
echo

exit 0
</source> 
Передача вывода от [[echo]] по конвейеру команде '''''read''''' может давать неожиданные результаты. В этом сценарии, команда '''''read''''' действует так, как будто бы она была запущена в подоболочке. Вместо неё лучше использовать команду '''''set'''''.
 '''Пример''': '''''Передача вывода от команды echo команде read, по конвейеру.'''''
<source lang="bash">
#!/bin/bash
# badread.sh:
# Попытка использования 'echo' и 'read'
# для записи значений в переменные.

a=aaa
b=bbb
c=ccc

echo "один два три" | read a b c# Попытка записать значения в переменные a, b и c.
echo
echo "a = $a" # a = aaa
echo "b = $b" # b = bbb
echo "c = $c" # c = ccc
# Присваивания не произошло.

# ------------------------------

# Альтернативный вариант.
var=`echo "один два три"`
set -- $var
a=$1; b=$2; c=$3

echo "-------"
echo "a = $a" # a = один
echo "b = $b" # b = два
echo "c = $c" # c = три
# На этот раз всё в порядке.

# ------------------------------

# Обратите внимание: в подоболочке 'read', для первого варианта, переменные присваиваются нормально.
# Но только в подоболочке.

a=aaa # Всё сначала.
b=bbb
c=ccc

echo; echo
echo "один два три" | ( read a b c;
echo "Внутри подоболочки: "; echo "a = $a"; echo "b = $b"; echo "c = $c" )
# a = один
# b = два
# c = три
echo "-------"
echo "Снаружи: "
echo "a = $a" # a = aaa
echo "b = $b" # b = bbb
echo "c = $c" # c = ccc
echo

exit 0
</source> 
Фактически, как указывает Anthony Richardson, передача вывода по конвейеру в любой цикл, может порождать аналогичные проблемы.
<source lang="bash">
# Проблемы с передачей данных в цикл по конвейеру.
# Этот пример любезно предоставил Anthony Richardson.

foundone=false
find $HOME -type f -atime +30 -size 100k |
while true
do
read f
echo "Файл $f имеет размер более 100KB и не использовался более 30 дней"
echo "Подумайте о перемещении этого файла в архив."
foundone=true
done

# Переменная foundone всегда будет иметь значение false, поскольку
# она устанавливается в пределах подоболочки

if [ $foundone = false ]
then
echo "Не найдено файлов, которые требуют архивации."
fi

# =====================А теперь правильный вариант:=================
foundone=false
for f in $(find $HOME -type f -atime +30 -size 100k) # Здесь нет конвейера.
do
echo "Файл $f имеет размер более 100KB и не использовался более 30 дней"
echo "Подумайте о перемещении этого файла в архив."
foundone=true
done

if [ $foundone = false ]
then
echo "Не найдено файлов, которые требуют архивации."
fi
</source> 
Подобные же проблемы возникают при попытке записать вывод от '''''tail -f''''' в конвейере с [[grep]].
<source lang="bash">
tail -f /var/log/messages | grep "$ERROR_MSG" >> error.log
# Ни одна запись не попадёт в файл "error.log".
</source> 
Огромный риск, для безопасности системы, представляет использование в скриптах команд, с установленным битом "''suid''". Использование сценариев в качестве CGI-приложений может приводить к серьёзным проблемам из-за отсутствия контроля типов переменных. Более того, они легко могут быть заменены взломщиком на его собственные сценарии. 
Bash не совсем корректно обрабатывает строки, содержащие двойной слэш (//). 
Сценарии на языке Bash, созданные для Linux или BSD систем, могут потребовать доработки, перед тем как они смогут быть запущены в коммерческой версии Unix. Такие сценарии, как правило, используют GNU-версии команд и утилит, которые имеют лучшую функциональность, нежели их аналоги в Unix. Это особенно справедливо для таких утилит обработки текста, как '''''tr'''''.
:::::::::::::::::::::::::::::::::::::::::::::''Danger is near thee —''
:::::::::::::::::::::::::::::::::::::::::::::''Beware, beware, beware, beware.''
:::::::::::::::::::::::::::::::::::::::::::::''Many brave hearts are asleep in the deep.''
:::::::::::::::::::::::::::::::::::::::::::::''So beware —''
:::::::::::::::::::::::::::::::::::::::::::::''Beware.''
:::::::::::::::::::::::::::::::::::::::::::::::::::'''''A.J. Lamb and H.W. Petrie'''''

== Стиль программирования ==
Возьмите в привычку структурный и систематический подход к программированию на языке командной оболочки. Даже для сценариев "выходного дня" и "писаных на коленке", не поленитесь, найдите время для того, чтобы разложить свои мысли по полочкам и продумать структуру будущего скрипта прежде чем приниматься за кодирование.
Ниже приводится несколько рекомендаций по оформлению сценариев, однако их не следует рассматривать как ''Официальное Руководство''.
=== Неофициальные рекомендации по оформлению сценариев ===
* '''''Комментируйте свой код. Это сделает ваши сценарии понятнее для других, и более простыми, в обслуживании, для вас'''''.
<source lang="bash">
PASS="$PASS${MATRIX:$(($RANDOM%${#MATRIX})):1}"
# Эта строка имела некоторый смысл в момент написания,
# но через год-другой будет очень тяжело вспомнить — что она делает.
# (Из сценария "pw.sh", автор: Antek Sawicki)
</source> 
Добавляйте заголовочные комментарии в начале сценария и перед функциями.
<source lang="bash">
#!/bin/bash
#************************************************#
# xyz.sh #
# автор: Bozo Bozeman #
# Июль 05, 2001 #
# #
# Удаление файлов проекта. #
#************************************************#
BADDIR=65 # Нет такого каталога.
projectdir=/home/bozo/projects # Каталог проекта.

# ------------------------------------------------------- #
# cleanup_pfiles () #
# Удаляет все файлы в заданном каталоге. #
# Параметры: $target_directory #
# Возвращаемое значение: 0 — в случае успеха, #
# $BADDIR — в случае ошибки. #
# ------------------------------------------------------- #

cleanup_pfiles ()
{
if [ ! -d "$1" ] # Проверка существования заданного каталога.
then
echo "$1 — не является каталогом."
return $BADDIR
fi

rm -f "$1"/*
return 0 # Успешное завершение функции.
}

cleanup_pfiles $projectdir

exit 0
</source> 
Не забывайте начинать ваш сценарий с ''sha-bang'' — '''''#!/bin/bash'''''. 

* '''''Заменяйте повторяющиеся значения константами. Это сделает ваш сценарий более простым для понимания и позволит вносить изменения, не опасаясь за его работоспособность'''''.
<source lang="bash">
if [ -f /var/log/messages ]
then
...
fi
# Представьте себе, что через пару лет
# вы захотите изменить /var/log/messages на /var/log/syslog.
# Тогда вам придётся отыскать все строки,
# содержащие /var/log/messages, и заменить их на /var/log/syslog.
# И проверить несколько раз — не пропустили ли что-нибудь.

# Использование "констант" даёт лучший способ:
LOGFILE=/var/log/messages # Если и придётся изменить, то только в этой строке.
if [ -f "$LOGFILE" ]
then
...
fi
</source> 
* '''''В качестве имён переменных и функций выбирайте осмысленные названия'''''.
<source lang="bash">
fl=`ls -al $dirname` # Не очень удачное имя переменной.
file_listing=`ls -al $dirname` # Уже лучше.

MAXVAL=10 # Пишите имена констант в верхнем регистре.
while [ "$index" -le "$MAXVAL" ]
...

E_NOTFOUND=75 # Имена кодов ошибок — в верхнем регистре,
# к тому же, их желательно дополнять префиксом "E_".
if [ ! -e "$filename" ]
then
echo "Файл $filename не найден."
exit $E_NOTFOUND
fi

MAIL_DIRECTORY=/var/spool/mail/bozo # Имена переменных окружения
# так же желательно записывать символами
# в верхнем регистре.
export MAIL_DIRECTORY

GetAnswer () # Смешивание символов верхнего и нижнего регистров
# удобно использовать для имён функций.
{
prompt=$1
echo -n $prompt
read answer
return $answer
}

GetAnswer "Ваше любимое число? "

favorite_number=$?
echo $favorite_number_user

variable=23 # Допустимо, но не рекомендуется.
# Желательно, чтобы пользовательские переменные не начинались с символа подчёркивания.
# Так обычно начинаются системные переменные.
</source> 
* '''''Используйте смысловые имена для кодов завершения'''''.
<source lang="bash">
E_WRONG_ARGS=65
...
...
exit $E_WRONG_ARGS
</source> 
* '''''Разделяйте большие сложные сценарии на серию более коротких и простых модулей. Пользуйтесь функциями'''''. 
* '''''Не пользуйтесь сложными конструкциями, если их можно заменить простыми'''''. 
<source lang="bash">
COMMAND
if [ $? -eq 0 ]
...
# Избыточно и неинтуитивно.
if COMMAND...
# Более понятно и коротко.
</source> 
:::::::::::::::::::::::::::::::::::::::::::''... читая исходные тексты сценариев на Bourne''
:::::::::::::::::::::::::::::::::::::::::::''shell (/bin/sh). Я был потрясен тем, насколько''
:::::::::::::::::::::::::::::::::::::::::::''непонятно и загадочно могут выглядеть очень''
:::::::::::::::::::::::::::::::::::::::::::''простые алгоритмы из-за неправильного''
:::::::::::::::::::::::::::::::::::::::::::''оформления кода. Я не раз спрашивал себя:''
:::::::::::::::::::::::::::::::::::::::::::''"Неужели кто-то может гордиться таким кодом?"''
:::::::::::::::::::::::::::::::::::::::::::::::::::::::'''Landon Noll'''

== Разное ==
::::::::::::::::::::::::::::::::::::::::::::''Практически никто не знает грамматики Bourne''
::::::::::::::::::::::::::::::::::::::::::::''shell-а. Даже изучение исходных текстов не даёт''
::::::::::::::::::::::::::::::::::::::::::::''её полного понимания''.
::::::::::::::::::::::::::::::::::::::::::::::::::::::::'''''Tom Duff'''''
=== Интерактивный и неинтерактивный режим работы ===
В ''интеракивном режиме'', оболочка читает команды, вводимые пользователем, с устройства ''tty''. Кроме того, такая оболочка считывает конфигурационные файлы на запуске, выводит строку приглашения к вводу (''prompt''), и, по-умолчанию, разрешает управление заданиями. Пользователь имеет возможность взаимодействия с оболочкой. \
Сценарий всегда запускается в неинтерактивном режиме. Но, не смотря на это, он сохраняет доступ к своему ''tty''. И даже может эмулировать интерактивный режим работы.
<source lang="bash">
#!/bin/bash
MY_PROMPT='$ '
while :
do
echo -n "$MY_PROMPT"
read line
eval "$line"
done
exit 0
# Этот сценарий, как иллюстрация к вышесказанному, предоставлен Stephane Chazelas (спасибо).
</source> 
Будем считать интерактивным такой сценарий, который может принимать ввод от пользователя, обычно с помощью команды '''read'''. В "реальной жизни" все намного сложнее. Пока же, будем придерживаться предположения о том, что интерактивный сценарий ограничен рамками ''tty'', с которого сценарий был запущен пользователемa, т.е консоль или окно ''xterm''. Сценарии начальной инициализации системы не являются интерактивными, поскольку они не предполагают вмешательство человека в процессе своей работы. Большая часть сценариев, выполняющих администрирование и обслуживание системы — так же работают в неинтерактивном режиме. Многие задачи автоматизации труда администратора очень трудно представить себе без неинтерактивных сценариев. Неинтерактивные сценарии прекрасно могут работать в фоне, в то время, как интерактивные — подвисают, останавливаясь на операциях, ожидающих ввода пользователя. Сложности, возникающие с запуском интерактивных сценариев в фоновом режиме, могут быть преодолены с помощью expect-сценария или встроенного документа. В простейших случаях, можно организовать перенаправление ввода из файла в команду '''read''' ('''''read variable <file'''''). Эти приёмы позволят создавать сценарии, которые смогут работать как в интерактивном, так и в неинтерактивном режимах. 
Если внутри сценария необходимо проверить режим работы — интерактивный или неинтерактивный, это можно сделать проверкой переменной окружения $PS1.
<source lang="bash">
if [ -z $PS1 ] # интерактивный режим?
then
# неинтерактивный
...
else
# интерактивный
...
fi
</source> 
Ещё один способ — проверка установки флага "i" в переменной $-.
<source lang="bash">
case $- in
*i*) # интерактивный режим
;;
*) # неинтерактивный режим
;;
# (Из "Unix F.A.Q.," 1993)
</source> 
Сценарий может принудительно запускаться в интерактивном режиме, для этого необходимо указать ключ ''-i'' в строке-заголовке '''''#!/bin/bash -i'''''. Однако вы должны помнить о том, что в таких случаях сценарий может выдавать сообщения об ошибках даже тогда, когда ошибок, по сути, нет.

=== Сценарии-обёртки ===
"Обёртки" — это сценарии, которые содержат один или несколько вызовов системных команд или утилит, с длинным списком параметров. Такой приём освобождает пользователя от необходимости вводить вручную сложные и длинные команды из командной строки. Он особенно полезен при работе с [[sed]] и [[awk]]. 
Сценарии [[sed]] или [[awk]], как правило вызываются в форме: '''''sed -e 'commands' ''''' или '''''awk 'commands' '''''. "Заворачивая" такие вызовы в сценарий на языке командной оболочки, мы делаем их использование более простым для конечного пользователя. Кроме того, этот приём позволяет комбинировать вызовы [[sed]] и [[awk]], например в конвейере, позволяя передавать данные с выхода одной утилиты на вход другой.
 '''Пример''': '''''Сценарий-обёртка.'''''
<source lang="bash">
#!/bin/bash

# Этот простой сценарий удаляет пустые строки из текстового файла.
# Проверка входных аргументов не производится.
#
# Однако вы можете дополнить сценарий такой проверкой,
# добавив нечто подобное:
# if [ -z "$1" ]
# then
# echo "Порядок использования: `basename $0` текстовый_файл"
# exit 65
# fi
# Для выполнения этих же действий,
# из командной строки можно набрать
# sed -e '/^$/d' filename

sed -e /^$/d "$1"
# '-e' — означает команду "editing" (правка), за которой следуют необязательные параметры.
# '^' — с начала строки, '$' — до её конца.
# Что соответствует строкам, которые не содержат символов между началом и концом строки,
# т.е. — пустым строкам.
# 'd' — команда "delete" (удалить).

# Использование кавычек даёт возможность
# обрабатывать файлы, чьи имена содержат пробелы.

exit 0
</source> 
 '''Пример''': '''''Более сложный пример сценария-обёртки.'''''
<source lang="bash">
#!/bin/bash
# "subst", Сценарий замены по шаблону
# т.е., "subst Smith Jones letter.txt".

ARGS=3
E_BADARGS=65 # Неверное число аргументов.

if [ $# -ne "$ARGS" ]
# Проверка числа аргументов.
then
echo "Проядок использования: `basename $0` old-pattern new-pattern filename"
exit $E_BADARGS
fi

old_pattern=$1
new_pattern=$2

if [ -f "$3" ]
then
file_name=$3
else
echo "Файл \"$3\" не найден."
exit $E_BADARGS
fi
# Здесь, собственно, выполняется сама работа по поиску и замене.
sed -e "s/$old_pattern/$new_pattern/g" $file_name
# 's' — команда "substitute" (замены),
# а /pattern/ — задаёт шаблон искомого текста.
# "g" — флаг "global" (всеобщий), означает "выполнить подстановку для *каждого*
# обнаруженного $old_pattern во всех строках, а не только в первой строке.

exit 0 # При успешном завершении сценария — вернуть 0.
</source> 
 '''Пример''': '''''Сценарий-обертка вокруг сценария awk.'''''
<source lang="bash">
#!/bin/bash
# Суммирует числа в заданном столбце из заданного файла.

ARGS=2
E_WRONGARGS=65

if [ $# -ne "$ARGS" ] # Проверка числа аргументов.
then
echo "Порядок использования: `basename $0` имя_файла номер_столбца"
exit $E_WRONGARGS
fi

filename=$1
column_number=$2

# Здесь используется прием передачи переменных
# из командной оболочки в сценарий awk .
# Многострочный сценарий awk должен записываться в виде: awk ' ..... '

# Начало awk-сценария.
# -----------------------------
awk '
{ total += $'"${column_number}"'
}
END {
print total
}
' "$filename"
# -----------------------------
# Конец awk-сценария.

# С точки зрения безопасности, передача shell-переменных
# во встроенный awk-скрипт, потенциально опасна,
# поэтому, Stephane Chazelas предлагает следующую альтернативу:
# ---------------------------------------
# awk -v column_number="$column_number" '
# { total += $column_number
# }
# END {
# print total
# }' "$filename"
# ---------------------------------------
exit 0
</source> 
Для сценариев, которые должны строиться по принципу швейцарского армейского ножа — "всё водном", можно порекомендовать '''''Perl'''''. '''''Perl''''' совмещает в себе мощь и гибкость [[sed]], [[awk]] и языка программирования '''''C'''''. Он поддерживает модульность и объектно-ориентированный стиль программирования. Короткие сценарии '''''Perl''''' могут легко встраиваться в сценарии командной оболочки, и даже полностью заменить из (хотя автор весьма скептически относится к последнему утверждению).
 '''Пример''': '''''Сценарий на языке Perl, встроенный в Bash-скрипт.'''''
<source lang="bash">
#!/bin/bash

# Это команды shell, предшествующий сценарию на Perl.
echo "Эта строка выводится средствами Bash, перед выполнением встроенного Perl-скрипта, в \"$0\"."
echo
"=============================================================================================="

perl -e 'print "Эта строка выводится средствами Perl.\n";'
# Подобно sed, Perl тоже использует ключ "-e".

echo "====================================="

exit 0
</source> 
Допускается даже комбинирование сценариев на Bash и на '''''Perl''''', в пределах одного файла. В зависимости от того, какая часть сценария должна исполняться, сценарий вызывается с указанием требуемого интерпретатора.
 '''Пример''': '''''Комбинирование сценария Bash и Perl в одном файле.'''''
<source lang="bash">
#!/bin/bash
#!/bin/bash
# bashandperl.sh
echo "Вас приветствует часть сценария, написанная на Bash."

# Далее могут следовать другие команды Bash.

exit 0
# Конец сценария на Bash.

# =======================================================

#!/usr/bin/perl
# Эта часть сценария должна вызываться с ключом -x.

print "Вас приветствует часть сценария, написанная на Perl.\n";
# Далее могут следовать другие команды Perl.

# Конец сценария на Perl.

bash$ bash bashandperl.sh
Вас приветствует часть сценария, написанная на Bash.

bash$ perl -x bashandperl.sh
Вас приветствует часть сценария, написанная на Perl.
</source> 
=== Операции сравнения: Альтернативные решения ===
Операции сравнения, выполняемые с помощью конструкции '''[[ ]]''', могут оказаться предпочтительнее,чем '''[ ]'''. Аналогично, при сравнении чисел, в более выгодном свете представляется конструкция '''(( ))'''.
<source lang="bash">
a=8

# Все, приведенные ниже, операции сравнения — эквивалентны.
test "$a" -lt 16 && echo "да, $a < 16" # "И-список"
/bin/test "$a" -lt 16 && echo "да, $a < 16"
[ "$a" -lt 16 ] && echo "да, $a < 16"
[[ $a -lt 16 ]] && echo "да, $a < 16" # Внутри [[ ]] и (( )) переменные
(( a < 16 )) && echo "да, $a < 16" # не обязательно брать в кавычки.

city="New York"
# Опять же, все, приведенные ниже, операции — эквивалентны.
test "$city" \< Paris && echo "Да, Paris больше, чем $city" # В смысле ASCII-строк.
/bin/test "$city" \< Paris && echo "Да, Paris больше, чем $city"
[ "$city" \< Paris ] && echo "Да, Paris больше, чем $city"
[[ $city < Paris ]] && echo "Да, Paris больше, чем $city" # Кавычки вокруг $city не обязательны.
# Спасибо S.C.
</source> 
=== Рекурсия ===
Может ли сценарий рекурсивно вызывать себя самого? Да, может!
 '''Пример''': '''''Сценарий (бесполезный), который вызывает себя сам.'''''
<source lang="bash">
#!/bin/bash
# recurse.sh

# Может ли сценарий вызвать себя сам?
# Да, но есть ли в этом смысл?

RANGE=10
MAXVAL=9
i=$RANDOM
let "i %= $RANGE" # Генерация псевдослучайного числа в диапазоне 0 .. $MAXVAL.

if [ "$i" -lt "$MAXVAL" ]
then
echo "i = $i"
./$0 # Сценарий запускает новый экземпляр себя самого.
fi # если число $i больше или равно $MAXVAL.
# Если конструкцию "if/then" заменить на цикл "while", то это вызовет определенные проблемы.
# Объясните — почему?.

exit 0
</source> 
 '''Пример''': '''''Сценарий (имеющий практическую ценность), который вызывает себя сам.'''''
<source lang="bash">
#!/bin/bash
#!/bin/bash
# pb.sh: телефонная книга
# Автор: Rick Boivie
# используется с его разрешения.
# Дополнен автором документа.

MINARGS=1 # Сценарию должен быть передан, по меньшей мере, один аргумент.
DATAFILE=./phonebook
PROGNAME=$0
E_NOARGS=70 # Ошибка, нет аргументов.

if [ $# -lt $MINARGS ]; then
echo "Порядок использования: "$PROGNAME" data"
exit $E_NOARGS
fi

if [ $# -eq $MINARGS ]; then
grep $1 "$DATAFILE"
else
( shift; "$PROGNAME" $* ) | grep $1
# Рекурсивный вызов.
fi
exit 0 # Сценарий завершает свою работу здесь.
# Далее следует пример файла телефонной книги
# в котором не используются символы комментария.

# ------------------------------------------------------------------------
# Пример файла телефонной книги
#John Doe 1555 Main St., Baltimore, MD 21228 (410) 222-3333
#Mary Moe 9899 Jones Blvd., Warren, NH 03787 (603) 898-3232
#Richard Roe 856 E. 7th St., New York, NY 10009 (212) 333-4567
#Sam Roe 956 E. 8th St., New York, NY 10009 (212) 444-5678
#Zoe Zenobia 4481 N. Baker St., San Franciso, SF 94338 (415) 501-1631
# ------------------------------------------------------------------------

$bash pb.sh Roe
Richard Roe 856 E. 7th St., New York, NY 10009 (212) 333-4567
Sam Roe 956 E. 8th St., New York, NY 10009 (212) 444-5678

$bash pb.sh Roe Sam
Sam Roe 956 E. 8th St., New York, NY 10009 (212) 444-5678
# Если сценарию передаются несколько аргументов,
# то выводятся только те строки, которые содержат их все.
</source> 
 '''Пример''': '''''Ещё один сценарий, который вызывает себя сам.'''''
<source lang="bash">
#!/bin/bash
# usrmnt.sh, автор Anthony Richardson
# Используется с его разрешения.

# Порядок использования: usrmnt.sh
# Описание: монтирует устройство, пользователь должен входить в состав группы
# MNTUSERS в файле /etc/sudoers.

# -----------------------------------------------------------------
# Этот сценарий рекурсивно вызывает себя самого,
# используя sudo. Пользователь, наделённый
# соответствующими правами может просто дать команду
# usermount /dev/fd0 /mnt/floppy
# вместо
# sudo usermount /dev/fd0 /mnt/floppy
# Подобную технику я использую во всех моих
# sudo-сценариях, поскольку она кажется мне достаточно удобной.
# -----------------------------------------------------------------

# Если переменная SUDO_COMMAND не определена, значит сценарий запущен не через
# sudo, поэтому повторно вызываем сценарий.
# Передавая user id и group id через переменные...

if [ -z "$SUDO_COMMAND" ]
then
mntusr=$(id -u) grpusr=$(id -g) sudo $0 $*
exit 0
fi
# В эту точку мы попадаем только если сценарий запущен через sudo
/bin/mount $* -o uid=$mntusr,gid=$grpusr

exit 0
# Дополнительные замечания от автора сценария:
# -------------------------------------------------

# 1) Linux допускает указание опции "users" в файле /etc/fstab,
# которая позволяет монтировать носители любому пользователю.
# Но на сервере я предпочитаю дать это право лишь отдельным
# пользователям. На мой взгляд sudo делает ситуацию более управляемой.

# 2) Я так же считаю, что утилита sudo более удобна, чем
# выполнение той же задачи посредством групп.

# 3) Эта методика выдает права root на доступ к команде
# mount, что требует особого внимания при выделении пользователей
# наделенных таким правом. Используя ту же самую технику,
# вы можете более точно разграничить права монтирования
# устройств, написав сценарии mntfloppy, mntcdrom и mntsamba.
</source> 
Слишком глубокая рекурсия может привести к исчерпанию пространства, выделенного под стек, и "вываливанию" сценария по "''segfault''".

=== "Цветные" сценарии ===
Для установки атрибутов отображения информации на экране, таких как: жирный текст, цвет символов, цвет фона и т.п., с давних пор используются ''ANSI'' escape-последовательности. Эти последовательности широко используются в пакетных файлах ''DOS'', эти же последовательности используются и в сценариях Bash.
 '''Пример''': '''''"Цветная" адресная книга.'''''
<source lang="bash">
#!/bin/bash
# ex30a.sh: Версия сценария ex30.sh, с добавлением цвета .
# Грубый пример базы данных

clear # Очистка экрана

echo -n " "
echo -e '\E[37;44m'"\033[1mСписок\033[0m"
# Белый текст на синем фоне
echo; echo
echo -e "\033[1mВыберите интересующую Вас персону:\033[0m"
# Жирный шрифт
tput sgr0
echo "(Введите только первую букву имени.)"
echo
echo -en '\E[47;34m'"\033[1mE\033[0m" # Синий
tput sgr0 # сброс цвета
echo "vans, Roland" # "[E]vans, Roland"
echo -en '\E[47;35m'"\033[1mJ\033[0m" # Пурпурный
tput sgr0
echo "ones, Mildred"
echo -en '\E[47;32m'"\033[1mS\033[0m" # Зелёный
tput sgr0
echo "mith, Julie"
echo -en '\E[47;31m'"\033[1mZ\033[0m" # Красный
tput sgr0
echo "ane, Morris"

echo
read personcase "$person" in
# Обратите внимание: переменная взята в кавычки.
"E" | "e" )
# Пользователь может ввести как заглавную, так и строчную букву.
echo
echo "Roland Evans"
echo "4321 Floppy Dr."
echo "Hardscrabble, CO 80753"
echo "(303) 734-9874"
echo "(303) 734-9892 fax"
echo "revans@zzy.net"
echo "Старый друг и партнер по бизнесу"
;;

"J" | "j" )
echo
echo "Mildred Jones"
echo "249 E. 7th St., Apt. 19"
echo "New York, NY 10009"
echo "(212) 533-2814"
echo "(212) 533-9972 fax"
echo "milliej@loisaida.com"
echo "Подружка"
echo "День рождения: 11 февраля"
;;

# Информация о Smith и Zane будет добавлена позднее.
* )
# Выбор по-умолчанию.
# "Пустой" ввод тоже обрабатывается здесь.
echo
echo "Нет данных."
;;

esac
tput sgr0
# Сброс цвета
echo

exit 0
</source> 
Самая простая и, на мой взгляд, самая полезная escape-последовательность — это "'''жирный текст'''", '''\033[1m ... \033[0m'''. Здесь, комбинация '''\033''' представляет escape-символ, комбинация '''[1''' — включает вывод жирным текстом, а '''[0''' — выключает. Символ '''m''' — завершает каждую из escape-последовательностей.
<source lang="bash">
bash$ echo -e "\033[1mЭто жирный текст.\033[0m"
</source> 
Простая escape-последовательность, которая управляет атрибутом подчеркивания (в ''rxvt'' и ''aterm'').
<source lang="bash">
bash$ echo -e "\033[4mЭто подчеркнутый текст.\033[0m"
</source> 
Ключ ''-e'', в команде [[echo]], разрешает интерпретацию escape-последовательностей. 
Другие escape-последовательности, изменяющие атрибуты цвета:
<source lang="bash">
bash$ echo -e '\E[34;47mЭтот текст выводится синим цветом.'; tput sgr0

bash$ echo -e '\E[33;44m'"жёлтый текст на синем фоне"; tput sgr0
</source> 
Команда '''tput sgr0''' возвращает настройки терминала в первоначальное состояние. echo -e '\E[COLOR1;COLOR2mКакой либо текст.'</source>
Где "'''\E['''" — начало escape-последовательности. Числа "'''COLOR1'''" и "'''COLOR2'''", разделённые точкой с запятой, задают цвет символов и цвет фона, в соответствии с таблицей цветов, приведенной ниже. (Порядок указания цвета текста и фона не имеет значения, поскольку диапазоны числовых значений цвета для текста и фона не пересекаются). Символ "'''m'''" — должен завершать escape-последовательность. 
Обратите внимание: одиночные кавычки окружают всё, что следует за '''''echo -e'''''.
|}
Числовые значения цвета, приведенные ниже, справедливы для ''rxvt''. Для других эмуляторов они могут несколько отличаться.
 '''Таблица. Числовые значения цвета в escape-последовательностях'''
{| class="wikitable"
|-
! Цвет !! Текст !! Фон
|-
| '''Чёрный''' || 30 || 40
|-
| '''Красный''' || 31 || 41
|-
| '''Зелёный''' || 32 || 42
|-
| '''Жёлтый''' || 33 || 43
|-
| '''Синий''' || 34 || 44
|-
| '''Пурпурный''' || 35 || 45
|-
| '''Зеленовато-голубой''' || 36 || 46
|-
| '''Белый''' || 37 || 47
|}
 '''Пример''': '''''Вывод цветного текста.'''''
<source lang="bash">
#!/bin/bash
# color-echo.sh: Вывод цветных сообщений.

black='\E[30;47m'
red='\E[31;47m'
green='\E[32;47m'
yellow='\E[33;47m'
blue='\E[34;47m'
magenta='\E[35;47m'
cyan='\E[36;47m'
white='\E[37;47m'

cecho () # Color-echo.
# Аргумент $1 = текст сообщения
# Аргумент $2 = цвет
{
local default_msg="Нет сообщений."
# Не обязательно должна быть локальной.

message=${1:-$default_msg} # Текст сообщения по-умолчанию.
color=${2:-$black} # Цвет по-умолчанию чёрный.

echo -e "$color"
echo "$message"
tput sgr0 # Восстановление первоначальных настроек терминала.
return
}

# Попробуем что-нибудь вывести.
# ----------------------------------------------------
cecho "Синий текст..." $blue
cecho "Пурпурный текст." $magenta
cecho "Позеленевший от зависти." $green
cecho "Похоже на красный?" $red
cecho "Циан, более известный как цвет морской волны." $cyan
cecho "Цвет не задан (по-умолчанию чёрный)."
# Аргумент $color отсутствует.
cecho "\"Пустой\" цвет (по-умолчанию чёрный)." ""
# Передан "пустой" аргумент цвета.
cecho
# Ни сообщение ни цвет не переданы.
cecho "" ""
# Функции переданы "пустые" аргументы $message и $color.
# ----------------------------------------------------

echo
exit 0
# Упражнения:
# ---------
# 1) Добавьте в функцию 'cecho ()' возможность вывода "жирного текста".
# 2) Добавьте возможность управления цветом фона.
</source> 
Однако, как обычно, в бочке меда есть ложка дегтя. Escape-последовательности ''ANSI'' совершенно не переносимы. Вывод в одном эмуляторе терминала (или в консоли) может разительно отличаться от вывода в другом эмуляторе. "Расцвеченные" сценарии, дающие изумительно красивый вывод текста на одном терминале, могут давать совершенно нечитаемый текст на другом. Это ставит под сомнение практическую ценность "расцвечивания" вывода в сценариях, низводя её до уровня никчёмной "игрушки". 
''Moshe Jacobson'' разработал утилиту ''color'' (http://runslinux.net/projects/color), которая значительно упрощает работу с ''ANSI'' escape-последовательностями, заменяя, только что обсуждавшиеся, неуклюжие конструкции, логичным и понятным синтаксисом.

=== Оптимизация ===
По большей части, сценарии на языке командной оболочки, используются для быстрого решения несложных задач. Поэтому оптимизация сценариев, по скорости исполнения, не является насущной проблемой. Тем не менее, представьте себе ситуацию, когда сценарий, выполняющий довольно важную работу, в принципе справляется со своей задачей, но делает это очень медленно. Написание же аналогичной программы на языке компилирующего типа — неприемлемо. Самое простое решение — переписать самые медленные участки кода сценария. Возможно ли применить принципы оптимизации к сценарию на практике? 
'''Для начала проверьте все циклы в сценарии. Основная масса времени уходит на работу в циклах. Если это возможно, вынесите все ресурсоёмкие операции за пределы циклов.
Старайтесь использовать встроенные команды. Они исполняются значительно быстрее и, как правило, не запускают подоболочку при вызове. Избегайте использования избыточных команд, особенно это относится к конвейерам.'''
<source lang="bash">
cat "$file" | grep "$word"

grep "$word" "$file"

# Эти команды дают один и тот же результат,
# но вторая работает быстрее, поскольку запускает на один подпроцесс меньше.
</source> 
'''Не следует злоупотреблять командой [[cat]]'''. 
Для профилирования сценариев, можно воспользоваться командами '''''time''''' и '''''times'''''. '''Не следует пренебрегать возможностью переписать особенно критичные участки кода на языке ''C'' или даже на ''ассемблере'' '''. 
'''Попробуйте минимизировать количество операций с файлами'''. Bash не "страдает" излишней эффективностью при работе с файлами, попробуйте применить специализированные средства для работы с файлами в сценариях, такие как [[awk]] или '''''Perl'''''. 
'''Записывайте сценарии в структурированной форме, это облегчит их последующую реорганизацию и оптимизацию'''. Помните, что значительная часть методов оптимизации кода, существующих в языках высокого уровня, вполне применима и к сценариям, однако есть и такие, которые не могут применяться. Основной критерий здесь — это '''''здравый смысл'''''.

=== Разные советы ===
* '''Для ведения учета использования сценария пользователями, добавьте следующие строки в сценарий. Они запишут в файл отчёта название сценария и время запуска'''.
<source lang="bash">
# Добавление (>>) учетной записи, об использовании сценария, в файл отчета.

date>> $SAVE_FILE # Дата и время.
echo $0>> $SAVE_FILE # Название сценария.
echo>> $SAVE_FILE # Пустая строка — как разделитель записей.

# Не забудьте определить переменную окружения SAVE_FILE в ~/.bashrc
# (что нибудь, типа: ~/.scripts-run)
</source> 

* '''Оператор '''>>''' производит добавление строки в конец файла. А как быть, если надо добавить строку в начало существующего файла'''?
<source lang="bash">
file=data.txt
title="***Это титульная строка в текстовом файле***"

echo $title | cat - $file >$file.new
# "cat -" объединяет stdout с содержимым $file.
# В результате получится
# новый файл $file.new, в начало которого добавлена строка $title.
</source> 
Само собой разумеется, то же самое можно сделать с помощью [[sed]]. 
* '''Сценарий командной оболочки может использоваться как команда внутри другого сценария командной оболочки, '''Tcl''', или '''wish''' сценария или, даже в ''Makefile'' '''. Он может быть вызван как внешняя команда из программы на языке ''C'', с помощью функции ''system()'', т.е. ''system("script_name");''. 
* '''Собирайте свои библиотеки часто используемых функций и определений '''. Эти "библиотеки" могут быть "подключены" к сценариям, с помощью команды точка ('''.''') или '''source'''.
<source lang="bash">
# Сценарий-библиотека
# ------ -------

# Обратите внимание:
# Здесь нет sha-bang ("#!").
# И нет "живого кода".

# Определения переменных
ROOT_UID=0 # UID root-а, 0.
E_NOTROOT=101 # Ошибка — "обычный пользователь".
MAXRETVAL=255 # Максимальное значение, которое могут возвращать функции.
SUCCESS=0
FAILURE=-1
# Функции
Usage () # Сообщение "Порядок использования:".
{
if [ -z "$1" ] # Нет аргументов.
then
msg=filename
else
msg=$@
fi
echo "Порядок использования: `basename $0` "$msg""
}

Check_if_root () # Проверка прав пользователя.
{ # из примера "ex39.sh".
if [ "$UID" -ne "$ROOT_UID" ]
then
echo "Этот сценарий должен запускаться с привилегиями root."
exit $E_NOTROOT
fi
}

CreateTempfileName () # Создание "уникального" имени для временного файла.
{ # Из примера "ex51.sh".
prefix=temp
suffix=`eval date +%s`
Tempfilename=$prefix.$suffix
}

isalpha2 () # Проверка, состоит ли строка только из алфавитных символов.
{ # Из примера "isalpha.sh".
[ $# -eq 1 ] || return $FAILURE

case $1 in
*[!a-zA-Z]*|"") return $FAILURE;;
*) return $SUCCESS;;
esac # Спасибо S.C.
}

abs () # Абсолютное значение.
{ # Внимание: Максимально возможное возвращаемое значение
# не может превышать 255.
E_ARGERR=-999999

if [ -z "$1" ] # Проверка наличия входного аргумента.
then
return $E_ARGERR # Код ошибки, обычно возвращаемый в таких случаях.
fi

if [ "$1" -ge 0 ] # Если не отрицательное,
then #
absval=$1 # оставить как есть.
else # Иначе,
let "absval = (( 0 - $1 ))" # изменить знак.
fi

return $absval
}

tolower () # Преобразование строк символов в нижний регистр
{
if [ -z "$1" ] # Если нет входного аргумента,
then # выдать сообщение об ошибке
echo "(null)"
return # и выйти из функции.
fi
echo "$@" | tr A-Z a-z
# Преобразовать все входные аргументы ($@).
return
# Для записи результата работы функции в переменную, используйте операцию подстановки команды.
# Например:
# oldvar="A seT of miXed-caSe LEtTerS"
# newvar=`tolower "$oldvar"`
# echo "$newvar" # a set of mixed-case letters
#
# Упражнение: Добавьте в эту библиотеку функцию перевода символов в верхний регистр.
# toupper() [это довольно просто].
}
</source> 
* '''Для повышения ясности комментариев, выделяйте их особым образом'''.
<source lang="bash">
## Внимание!
rm -rf *.zzy ## Комбинация ключей "-rf", в команде "rm", чрезвычайно опасна,
## особенно при удалении по шаблону.
# Продолжение комментария на новой строке.
# Это первая строка комментария
# это вторая строка комментария,
# это последняя строка комментария.

#* Обратите внимание.
#o Элемент списка.
#> Альтернативный вариант.
while [ "$var1" != "end" ] #> while test "$var1" != "end"
</source> 
* '''Для создания блочных комментариев, можно использовать конструкцию if-test'''.
<source lang="bash">
#!/bin/bash
COMMENT_BLOCK=
# Если попробовать инициализировать эту переменную чем-нибудь,
# то вы получите неожиданный результат.

if [ $COMMENT_BLOCK ]; then
Блок комментария --
=================================
Это строка комментария.
Это другая строка комментария.
Это ещё одна строка комментария.
=================================
echo "Эта строка не выводится."
Этот блок комментария не вызывает сообщения об ошибке! Круто!
fi

echo "Эта строка будет выведена на stdout."

exit 0
</source> 
Сравните этот вариант создания блочных комментариев со встроенным документом, использующимся для создания блочных комментариев. 
* '''С помощью служебной переменной $?, можно проверить — является ли входной аргумент целым числом'''.
<source lang="bash">
#!/bin/bash
SUCCESS=0
E_BADINPUT=65
test "$1" -ne 0 -o "$1" -eq 0 2>/dev/null
# Проверка: "равно нулю или не равно нулю".
# 2>/dev/null подавление вывода сообщений об ошибках.

if [ $? -ne "$SUCCESS" ]
then
echo "Порядок использования: `basename $0` целое_число"
exit $E_BADINPUT
fi
let "sum = $1 + 25" # Будет выдавать ошибку, если $1 не является целым числом.
echo "Sum = $sum"
# Любая переменная может быть проверена таким образом, а не только входные аргументы.

exit 0
</source> 
* '''Диапазон, возвращаемых функциями значений, 0-255 — серьёзное ограничение. Иногда может оказаться весьма проблематичным использование глобальных переменных, для передачи результата из функции. В таких случаях можно порекомендовать передачу результатов работы функции через запись в ''stdout''. Фактически этот приём является разновидностью подстановки команд'''.
 '''Пример''': '''''Необычный способ передачи возвращаемого значения.'''''
<source lang="bash">
#!/bin/bash
# multiplication.sh
multiply () # Функции выполняет перемножение всех переданных аргументов.
{
local product=1
until [ -z "$1" ] # Пока не дошли до последнего аргумента...
do
let "product *= $1"
shift
done
echo $product # Значение не будет выведено на экран,
} # поскольку оно будет записано в переменную.

mult1=15383; mult2=25211
val1=`multiply $mult1 $mult2`
echo "$mult1 X $mult2 = $val1"
# 387820813
mult1=25; mult2=5; mult3=20
val2=`multiply $mult1 $mult2 $mult3`
echo "$mult1 X $mult2 X $mult3 = $val2"
# 2500

mult1=188; mult2=37; mult3=25; mult4=47
val3=`multiply $mult1 $mult2 $mult3 $mult4`
echo "$mult1 X $mult2 X $mult3 X mult4 = $val3"
# 8173300
exit 0
</source> 
Такой приём срабатывает и для строковых значений. Таким образом, функция может "возвращать" и нечисловой результат.
<source lang="bash">
capitalize_ichar () # Первый символ всех строковых аргументов
{ # переводится в верхний регистр.
string0="$@" # Принять все аргументы.

firstchar=${string0:0:1} # Первый символ.
string1=${string0:1} # Остаток строки.
FirstChar=`echo "$firstchar" | tr a-z A-Z`
# Преобразовать в верхний регистр.
echo "$FirstChar$string1" # Выдать на stdout.
}
newstring=`capitalize_ichar "each sentence should start with a capital letter."`
echo "$newstring" # Each sentence should start with a capital letter.
</source> 
Используя этот приём, функция может "возвращать" даже несколько значений.
 '''Пример''': '''''Необычный способ получения нескольких возвращаемых значений.'''''
<source lang="bash">
#!/bin/bash
# sum-product.sh
# Функция может "возвращать" несколько значений.

sum_and_product () # Вычисляет сумму и произведение аргументов.
{
echo $(( $1 + $2 )) $(( $1 * $2 ))
# Вывод на stdout двух значений, разделенных пробелом.
}

echo
echo "Первое число: "
read first

echo
echo "Второе число: "
read second
echo

retval=`sum_and_product $first $second` # Получить результат.
sum=`echo "$retval" | awk '{print $1}'` # Первое значение (поле).
product=`echo "$retval" | awk '{print $2}'` # Второе значение (поле).

echo "$first + $second = $sum"
echo "$first * $second = $product"
echo

exit 0
</source> 
* '''Следующая хитрость — передача массива в функцию, и "возврат" массива из функции'''.
Передача массива в функцию выполняется посредством записи элементов массива,разделенных пробелами, в переменную, с помощью операции подстановки команды. Получить массив обратно можно, следуя вышеописанной стратегии, через вывод на ''stdout'', а затем, с помощью всё той же операции подстановки команды и оператора '''( ... )''' — записать в массив.
 '''Пример''': '''''Передача массива в функцию и возврат массива из функции.'''''
<source lang="bash">
#!/bin/bash
# array-function.sh: Передача массива в функцию и...
# "возврат" массива из функции
Pass_Array ()
{
local passed_array # Локальная переменная.
passed_array=( `echo "$1"` )
echo "${passed_array[@]}"
# Список всех элементов в новом массиве,
# объявленном и инициализированном в функции.
}

original_array=( element1 element2 element3 element4 element5 )

echo
echo "original_array = ${original_array[@]}"
# Список всех элементов исходного массива.

# Так можно отдать массив в функцию.
# **********************************
argument=`echo ${original_array[@]}`
# **********************************
# Поместив все элементы массива в переменную, разделяя их пробелами.
#
# Обратите внимание: метод прямой передачи массива в функцию не сработает.

# Так можно получить массив из функции.
# *****************************************
returned_array=( `Pass_Array "$argument"` )
# *****************************************
# Записать результат в переменную-массив.

echo "returned_array = ${returned_array[@]}"

echo "============================================================="

# А теперь попробуйте получить доступ к локальному массиву
# за пределами функции.
Pass_Array "$argument"

# Функция выведет массив, но...
# доступ к локальному массиву, за пределами функции, окажется невозможен.
echo "Результирующий массив (внутри функции) = ${passed_array[@]}"
# "ПУСТОЕ" ЗНАЧЕНИЕ, поскольку это локальная переменная.

echo
exit 0
</source> 

* '''Использование конструкций с двойными круглыми скобками позволяет применять ''C''-подобный синтаксис операций присвоения и инкремента переменных, а также оформления циклов ''for'' и ''while'' '''. 
* '''Иногда очень удобно "пропускать" данные через один и тот же фильтр, но с разными параметрами, используя конвейерную обработку. Особенно это относится к '''''tr''''' и [[grep]]'''.
<source lang="bash">
# Из примера "wstrings.sh".
wlist=`strings "$1" | tr A-Z a-z | tr '[:space:]' Z | \
tr -cs '[:alpha:]' Z | tr -s '\173-\377' Z | tr Z ' '`
</source> 
 '''Пример''': '''''Игры с анаграммами.'''''
<source lang="bash">
#!/bin/bash
# agram.sh: Игры с анаграммами.

# Поиск анаграмм...
LETTERSET=etaoinshrdlu
anagram "$LETTERSET" | # Найти все анаграммы в наборе символов...
grep '.......' | # состоящие, как минимум из 7 символов,
grep '^is' | # начинающиеся с 'is'
grep -v 's$' | # исключая множественное число
grep -v 'ed$' # и глаголы в прошедшем времени

# Здесь используется утилита "anagram"
# которая входит в состав пакета "yawl" , разработанного автором.
# http://ibiblio.org/pub/Linux/libs/yawl-0.2.tar.gz
exit 0
# Конец.

bash$ sh agram.sh
islander
isolate
isolead
isotheral
</source> 

* '''Для создания блочных комментариев можно использовать "анонимные встроенные документы"'''. 
* '''Попытка вызова утилиты из сценария на машине, где эта утилита отсутствует, потенциально опасна. Для обхода подобных проблем можно воспользоваться утилитой whatis'''.
<source lang="bash">
CMD=command1 # Основной вариант.
PlanB=command2 # Запасной вариант.

command_test=$(whatis "$CMD" | grep 'nothing appropriate')
# Если 'command1' не найдена в системе, то 'whatis' вернёт
# "command1: nothing appropriate."
#==> От переводчика: Будьте внимательны! Если у вас локализованная версия whatis
#==> то вывод от неё может отличаться от используемого здесь ('nothing appropriate')

if [[ -z "$command_test" ]] # Проверка наличия утилиты в системе.
then
$CMD option1 option2 # Запуск команды с параметрами.
else # Иначе,
$PlanB # запустить command2 (запасной вариант).
fi
</source> 
* '''Команда run-parts удобна для запуска нескольких сценариев, особенно в комбинации с '''''cron''''' или '''''at''''' '''. 
* '''Иногда было бы неплохо снабдить сценарий графическим интерфейсом ''X-Window'' '''. Для этого можно порекомендовать пакеты ''Xscript'', ''Xmenu'' и ''widtools''. Правда, первые два, кажется больше не поддерживаются разработчиками. Зато ''widtools'' можно получить [http://www.batse.msfc.nasa.gov/~mallozzi/home/software/xforms/src/widtools-2.0.tgz здесь].
Пакет ''widtools'' (widget tools) требует наличия библиотеки ''XForms''. Кроме того, необходимо слегка подправить ''Makefile'', чтобы этот пакет можно было собрать на типичной Linux-системе. Но хуже всего то, что три из шести виджетов не работают :-(( (segfault). 
Утилита ''dialog'' — ещё один способ создания диалоговых форм из сценариев командной оболочки. Эта утилита предназначена для работы в текстовой консоли, но имеются её "наследники" — ''gdialog'', ''Xdialog'' и ''kdialog'', которые используют графические элементы ''X-Windows'' для построения диалоговых форм. 
 '''Пример''': '''''Сценарий с графическим интерфейсом.'''''
<source lang="bash">
#!/bin/bash
# dialog.sh: Использование виджетов 'gdialog'.
# В вашей системе должна быть установлена утилита 'gdialog'.

# Идея создания этого сценария появилась после прочтения статьи
# "Scripting for X Productivity," by Marco Fioretti,
# LINUX JOURNAL, Issue 113, September 2003, pp. 86-9.
# Спасибо всем сотрудникам LJ.

# Ошибка ввода в диалоговом окне.
E_INPUT=65
# Размеры окна.
HEIGHT=50
WIDTH=60

# Имя выходного файла (конструируется добавлением суффикса к имени файла-сценария).
OUTFILE=$0.output

# Вывести содержимое файла-сценария в отдельном окне.
gdialog --title "Displaying: $0" --textbox $0 $HEIGHT $WIDTH

# Попробуем записать значение, введенное в окне.
echo -n "VARIABLE=\"" > $OUTFILE # Кавычка на случай, если пользователь введет несколько слов, разделенных пробелами.
gdialog --title "User Input" --inputbox "Введите значение переменной:" \
$HEIGHT $WIDTH >> $OUTFILE

if [ "$?" -eq 0 ]
# Хороший тон — проверка кода завершения.
then
echo "Диалог с пользователем завершился без ошибок."
else
echo "Обнаружены ошибки во время диалога с пользователем."
# Или была нажата кнопка "Отменить" ("Cancel") вместо "OK".
rm $OUTFILE
exit $E_INPUT
fi
echo -n "\"" >> $OUTFILE # Завершающая кавычка.
# Теперь прочитаем значение переменной из файла и выведем его.
. $OUTFILE # 'Выходной' файл.
echo "Было введено значение переменной: "$VARIABLE""
rm $OUTFILE # Удалить временный файл.
exit 0
</source> 
Кроме того, для построения приложений с графическим интерфейсом, можно попробовать ''Tk'', или ''wish'' (надстройка над ''Tcl''), ''PerlTk'' (''Perl'' с поддержкой ''Tk''), ''tksh'' (''ksh'' с поддержкой ''Tk''), ''XForms4Perl'' (''Perl'' с поддержкой ''XForms''), ''Gtk-Perl'' (''Perl'' с поддержкой ''Gtk'') или ''PyQt'' (''Python'' с поддержкой ''Qt'').
=== Проблемы безопасности ===
Уместным будет лишний раз предупредить о соблюдении мер предосторожности при работе с незнакомыми сценариями. Сценарий может содержать червя, трояна или даже вирус. Если вы получили сценарий не из источника, которому доверяете, то никогда не запускайте его с привилегиями ''root'' и не позволяйте вставлять его в список сценариев начальной инициализации системы в ''/etc/rc.d'', пока не убедитесь в том, что он безвреден для системы. Исследователи из Bell Labs и других организаций, включая ''M. Douglas McIlroy'', ''Tom Duff'', и ''Fred Cohen'' исследовали вопрос о возможности создания вирусов на языке сценариев командной оболочки, и пришли к выводу, что это делается очень легко и доступно даже для новичков.
Это ещё одна из причин, по которым следует изучать язык командной оболочки. Способность читать и понимать сценарии поможет вам предотвратить возможность взлома и/или разрушения вашей системы.
=== Проблемы переносимости ===
Эта книга делает упор на создании сценариев для командной оболочки Bash, для операционной системы GNU/Linux. Тем не менее, многие рекомендации, приводимые здесь, могут быть вполне применимы и для других командных оболочек, таких как ''sh'' и ''ksh''. Многие версии командных оболочек стремятся следовать стандарту POSIX 1003.2. Вызывая Bash с ключом ''--posix'', или вставляя ''set -o posix'' в начало сценария, вы можете заставить Bash очень близко следовать этому стандарту. Но, даже без этого ключа, большинство сценариев, написанных для Bash, будут работать под управлением ''ksh'', и наоборот, т.к. Chet Ramey перенес многие особенности, присущие ''ksh'', в последние версии Bash. В коммерческих версиях Unix, сценарии, использующие GNU-версии стандартных утилит и команд, могут оказаться неработоспособными. Однако, с течением времени, таких проблем остается всё меньше и меньше, поскольку утилиты GNU, в большинстве своем, заместили свои проприетарные аналоги в Unix. После того, как Caldera дала разрешение на публикацию исходного кода некоторых версий оригинальных утилит Unix, этот процесс значительно ускорился. Bash имеет некоторые особенности, недоступные в традиционном Bourne shell. Среди них: 
* Некоторые дополнительные ключи вызова 
* Подстановка команд, с использованием нотации $( ) 
* Некоторые операции над строками 
* Подстановка процессов 
* Встроенные команды Bash 
Более подробный список характерных особенностей Bash, вы найдете в [ftp://ftp.cwru.edu/pub/bash/FAQ/ Bash F.A.Q.].

=== Сценарии командной оболочки под Windows ===
Даже те пользователи, которые работают в другой, не Unix-подобной операционной системе, смогут запускать сценарии командной оболочки, а потому — найти для себя много полезного в этой книге. Пакеты '''''Cygwin''''' от ''Cygnus'', и '''''MKS utilities''''' от ''Mortice Kern Associates'', позволяют дополнить Windows возможностями командной оболочки.

== Bash, версия 2 ==
Текущая версия Bash, та, которая скорее всего установлена в вашей системе, фактически — 2.XX.Y(На момент написания/перевода книги).
<source lang="bash">
bash$ echo $BASH_VERSION
2.05.b.0(1)-release
</source> 
В этой версии классического языка сценариев Bash были добавлены переменные-массивы, расширение строк и подстановка параметров, улучшен метод косвенных ссылок на переменные.
 '''Пример''': '''''Расширение строк.'''''
<source lang="bash">
#!/bin/bash
# "Расширение" строк (String expansion).
# Введено в Bash, начиная с версии 2.
# Строки вида $'xxx'
# могут содержать дополнительные экранированные символы.

echo $'Звонок звенит 3 раза \a \a \a'
echo $'Три перевода формата \f \f \f'
echo $'10 новых строк \n\n\n\n\n\n\n\n\n\n'

exit 0
</source> 
 '''Пример''': '''''Косвенные ссылки на переменные — новый метод.'''''
<source lang="bash">
#!/bin/bash
# Косвенные ссылки на переменные.

a=letter_of_alphabet
letter_of_alphabet=z

echo "a = $a" # Прямая ссылка.

echo "Now a = ${!a}" # Косвенная ссылка.
# Форма записи ${!variable} намного удобнее старой "eval var1=\$$var2"

echo

t=table_cell_3
table_cell_3=24
echo "t = ${!t}" # t = 24
table_cell_3=387
echo "Значение переменной t изменилось на ${!t}" # 387
# Теперь их можно использовать для ссылок на элементы массива,
# или для эмуляции многомерных массивов.
# Было бы здорово, если бы косвенные ссылки допускали индексацию.

exit 0
</source> 
 '''Пример''': '''''Простая база данных, с применением косвенных ссылок.'''''
<source lang="bash">
#!/bin/bash
# resistor-inventory.sh

# Простая база данных, с применением косвенных ссылок.
# ============================================================== #
# Данные

B1723_value=470 # сопротивление (Ом)
B1723_powerdissip=.25 # рассеиваемая мощность (Вт)
B1723_colorcode="желтый-фиолетовый-коричневый" # цветовая маркировка
B1723_loc=173 # где
B1723_inventory=78 # количество (шт)

B1724_value=1000
B1724_power
dissip=.25
B1724_colorcode="коричневый-черный-красный"
B1724_loc=24
NB1724_inventory=243

B1725_value=10000
B1725_powerdissip=.25
B1725_colorcode="коричневый-черный-оранжевый"
B1724_loc=24
NB1724_inventory=243

B1725_value=10000
B1725_powerdissip=.25
B1725_colorcode="коричневый-черный-оранжевый"
B1725_loc=24
NB1725_inventory=89

# ============================================================== #

echo

PS3='Введите номер: '

echo

select catalog_number in "B1723" "B1724" "B1725"
do
Inv=${catalog_number}_inventory
Val=${catalog_number}_value
Pdissip=${catalog_number}_powerdissip
Loc=${catalog_number}_loc
Ccode=${catalog_number}_colorcode

echo
echo "Номер по каталогу $catalog_number:"
echo "Имеется в наличии ${!Inv} шт. [${!Val} Ом / ${!Pdissip} Вт]."
echo "Находятся в лотке # ${!Loc}."
echo "Цветовая маркировка: \"${!Ccode}\"."

break

done

echo; echo# Упражнение:
# ----------
# Переделайте этот сценарий так, чтобы он использовал массивы вместо косвенных ссылок.
# Какой из вариантов более простой и интуитивный?

# Примечание:
# ----------
# Язык командной оболочки не очень удобен для написания приложений,
# работающих с базами данных.
# Для этой цели лучше использовать языки программирования, имеющие
# развитые средства для работы со структурами данных,
# такие как C++ или Java (может быть Perl).

exit 0
</source> 
 '''Пример''': '''''Массивы и другие хитрости для раздачи колоды карт в четыре руки.'''''
<source lang="bash">
#!/bin/bash
# На старых системах может потребоваться вставить #!/bin/bash2.

# Карты:
# раздача в четыре руки.

UNPICKED=0
PICKED=1

DUPE_CARD=99
LOWER_LIMIT=0
UPPER_LIMIT=51
CARDS_IN_SUIT=13
CARDS=52

declare -a Deckdeclare -a Suitsdeclare -a Cards
# Проще и понятнее было бы, имей мы дело
# с одним 3-мерным массивом.
# Будем надеяться, что в будущем, поддержка многомерных массивов будет введена в Bash.

initialize_Deck ()
{
i=$LOWER_LIMIT
until [ "$i" -gt $UPPER_LIMIT ]
do
Deck[i]=$UNPICKED # Пометить все карты в колоде "Deck", как "невыданная".
let "i += 1"
done
echo
}

initialize_Suits ()
{
Suits[0]=Т # Трефы
Suits[1]=Б # Бубны
Suits[2]=Ч # Червы
Suits[3]=П # Пики
}

initialize_Cards ()
{
Cards=(2 3 4 5 6 7 8 9 10 В Д K Т)
# Альтернативный способ инициализации массива.
}

pick_a_card ()
{
card_number=$RANDOM
let "card_number %= $CARDS"
if [ "${Deck[card_number]}" -eq $UNPICKED ]
then
Deck[card_number]=$PICKED
return $card_number
else
return $DUPE_CARD
fi
}

parse_card ()
{
number=$1
let "suit_number = number / CARDS_IN_SUIT"
suit=${Suits[suit_number]}
echo -n "$suit-"
let "card_no = number % CARDS_IN_SUIT"
Card=${Cards[card_no]}
printf %-4s $Card
# Вывод по столбцам.
}

seed_random () # Переустановка генератора случайных чисел.
{
seed=`eval date +%s`
let "seed %= 32766"
RANDOM=$seed
}

deal_cards ()
{
echo

cards_picked=0
while [ "$cards_picked" -le $UPPER_LIMIT ]
do
pick_a_card
t=$?
if [ "$t" -ne $DUPE_CARD ]
then
parse_card $t
u=$cards_picked+1
# Возврат к индексации с 1 (временно).
let "u %= $CARDS_IN_SUIT"
if [ "$u" -eq 0 ] # вложенный if/then.
then
echo
echo
fi
# Смена руки.
let "cards_picked += 1"
fi
done

echo

return 0
}
# Структурное программирование:
# вся логика приложения построена на вызове функций.
#================

seed_random
initialize_Deck
initialize_Suits
initialize_Cards
deal_cards

exit 0
#================
# Упражнение 1:
# Добавьте комментарии, чтобы до конца задокументировать этот сценарий.
# Упражнение 2:
# Исправьте сценарий так, чтобы карты в каждой руке выводились отсортированными по масти.
# Вы можете добавить и другие улучшения.
# Упражнение 3:
# Упростите логику сценария.
</source> 

= Замечания и дополнения =

== От автора ==
Как я пришёл к мысли о написании этой книги? Это необычная история. Случилось это лет несколько тому назад. Мне потребовалось изучить язык командной оболочки — а что может быть лучше, как нечтение хорошей книги!? Я надеялся купить учебник и справочник, которые охватывали бы в полной мере данную тематику. Я искал книгу, которая возьмёт трудные понятия, вывернет их наизнанку и подробно разжует на хорошо откомментированных примерах. В общем, я искал очень хорошую книгу. К сожалению, в природе таковой не существовало, поэтому я счёл необходимым написать её. 
Это напоминает мне сказку о сумасшедшем профессоре. Помешанный, до безумия, при виде книги, любой книги — в библиотеке, в книжном магазине — не важно где, им овладевала уверенность в том, что и он мог бы написать эту книгу, причём мог бы сделать это гораздо лучше. Он стремительно мчался домой и садился за создание своей собственной книги с тем же названием. Когда он умер, в его доме нашли несколько тысяч, написанных им книг, этого количества хватило бы, чтобы посрамить самого Айзека Азимова. Книги, может быть и не были так хороши — кто знает, но разве это имеет какое-то значение? Вот — человек, жил своими грёзами, пусть одержимый и движимый ими, но я не могу удержаться от восхищения старым чудаком...

== Об авторе ==
Автор не стремится ни к званиям, ни к наградам, им движет неодолимое желание писать. Эта книга — своего рода отдых от основной работы, HOW-2 Meet Women: The Shy Man's Guide to Relationships (Руководство Застенчивого Мужчины о том Как Познакомиться С Женщиной) . Он также написал Software-Building HOWTO. В последнее время он пробует себя в беллетристике. 
Пользуется Linux с 1995 года (Slackware 2.2, kernel 1.2.1). Выпустил несколько программ, среди которых '''cruft''' — утилита шифрования, заменявшая стандартную Unix-овую '''crypt''', '''mcalc''' — финансовый калькулятор, для выполнения расчетов по займам, '''judge''' и '''yawl''' — пакет игр со словами. Программировать начинал с языка ''FORTRAN IV'' на ''CDC 3800'', но не испытывает ностальгии по тем дням. Живёт в глухой, заброшенной деревушке со своей женой и собакой.

== Куда обращаться за помощью ==
Автор('''''thegrendel@theriver.com''''') этой книги обычно не оставляет без ответа задаваемые ему вопросы (если он не слишком занят и пребывает в добром расположении духа). Однако, если вы испытываете проблемы со специфическим сценарием, то вам лучше обратиться на [comp.os.unix.shell] ''Usenet newsgroup''.

== Инструменты, использовавшиеся при создании книги ==

=== Аппаратура ===
IBM Thinkpad, model 760XL laptop (P166, 104 Mb RAM) под управлением Red Hat 7.1/7.3. Несомненно,это довольно медлительный агрегат, но он имеет отличную клавиатуру, и это много лучше, чем пара карандашей и письменный стол.

=== Программное обеспечение ===
* Мощный текстовый редактор [[vim]] (автор: Bram Moolenaar).
* [http://openjade.sourceforge.net/ OpenJade] — инструмент, выполняющий, на основе DSSSL, верификацию и преобразование SGML-документов в другие форматы.
* Таблицы стилей DSSSL от Norman Walsh.
* ''DocBook'', ''The Definitive Guide'' (Norman Walsh, Leonard Muellner O'Reilly, ISBN 1-56592-580-7). Полное руководство по созданию документов в формате Docbook SGML.

== Благодарности ==
Без участия сообщества этот проект был бы невозможен. Автор признаёт, что без посторонней помощи, написание этой книги стало бы невыполнимой задачей и благодарит всех, кто оказал посильную помощь. 
* Philippe Martin — перевёл этот документ в формат DocBook/SGML. Работает в маленькой французской компании, в качестве разработчика программного обеспечения. В свободное от работы время — любит работать над документацией или программным обеспечением для ''GNU/Linux'', читать книги, слушать музыку и веселиться с друзьями. Вы можете столкнуться с ним, где-нибудь во Франции, в провинции Басков, или написать ему письмо на ''feloy@free.fr''. Philippe Martin также отметил, что возможно использование позиционных параметров за '''$9''', при использовании '''{фигурных скобок}'''.

* Stephane Chazelas — выполнил титаническую работу по корректировке, дополнению и написанию примеров сценариев. Фактически, он взвалил на свои плечи обязанности редактора этого документа. Огромное спасибо!

* Paulo Marcel Coelho Aragao предложил большое количество дополнений и изменений, как важных, таки не очень. А также дал ряд дельных советов. 
Особенно я хотел бы поблагодарить ''Patrick Callahan'', ''Mike Novak'' и ''Pal Domokos'' за исправление ошибок и неточностей, за разъяснения и дополнения. Их живое обсуждение проблем, связанных с созданием сценариев на языке командной оболочки вдохновило меня на попытку сделать этот документ более удобочитаемым. 
Я благодарен ''Jim Van Zandt'' за выявленные им ошибки и упущения, в версии 0.2 этого документа, и за поучительный пример сценария. 
Большое спасибо Jordi Sanfeliu за то, что он дал возможность использовать его прекрасный сценарий в этой книге. 
Выражаю свою благодарность Michel Charpentier за разрешение использовать его '''''dc''''' сценарий разложения на простые множители. 
Спасибо Noah Friedman, предоставившему право использовать его сценарий.
Emmanuel Rouat предложил несколько изменений и дополнений в разделах, посвящённых подстановке команд и псевдонимам. Он так же предоставил замечательный пример файла ''.bashrc'' (Приложение I). 
Heiner Steven любезно разрешил опубликовать его сценарий. Он сделал множество исправлений и внёс большое количество предложений. Особое спасибо! 
''Rick Boivie'' предоставил отличный сценарий, демонстрирующий рекурсию, pb.sh и внёс предложения по повышению производительности сценария monthlypmt.sh. ''Florian Wisser'' оказывал содействие при написании разделов, посвящённых строкам. ''Oleg Philon'' передал свои предложения относительно команд '''cut''' и '''pidof'''. ''Michael Zick'' расширил пример с пустыми массивами, введя туда демонстрацию необычных свойств массивов. Он также предоставил ряд других примеров. ''Marc-Jano Knopp'' выполнил исправления в разделе, посвящённом пакетным файлам DOS. ''Hyun Jin Cha'', в процессе работы над корейским переводом, обнаружил несколько опечаток в документе. Спасибо ему за это! ''Andreas Abraham'' передал большое число типографских ошибок и внёс ряд исправлений. Особое спасибо! 
Кроме того, я хотел бы выразить свою признательность за примеры сценариев, исправление моих ошибок и полезные советы ''Gabor Kiss, Leopold Toetsch, Peter Tillier, Marcus Berglof, Tony Richardson,Nick Drage, Rich Bartell, Jess Thrysoee, Adam Lazur, Bram Moolenaar, Baris Cicek, Greg Keraunen, KeithMatthews, Sandro Magi, Albert Reiner, Dim Segebart, Rory Winston, Lee Bigelow, Wayne Pollock, "jipe,"Emilio Conti, Dennis Leeuw, Dan Jacobson, Aurelio Marinho Jargas, Edward Scholtz, Jean Helou, ChrisMartin, Lee Maschmeyer, Bruno Haible, Sebastien Godard, Bjіn Eriksson, "nyal," John MacDonald, JoshuaTschida, Troy Engel, Manfred Schwarb, Amit Singh, Bill Gradwohl, David Lombard, Jason Parker, Bruce W.Clare, William Park, and David Lawyer''(автор 4-х HOWTO). 
Мои благодарности Chet Ramey(chet@po.cwru.edu) и ''Brian Fox'' за создание '''''Bash''''' — этого элегантного и мощного инструмента! 
Особое спасибо добровольцам из [http://www.tldp.org/ Linux Documentation Project]. Проект LDP сделал возможным публикацию этой книги в своём архиве. 
Особую признательность хочу выразить IBM, Novell, Red Hat, [http://www.fsf.org/ Free Software Foundation] и всем замечательным людям, которые бьются за то, чтобы программное обеспечение ''Open Source'' оставалось свободным и открытым. 
'''''Больше всего я хотел бы выразить свою благодарность моей супруге, Anita, за ее эмоциональную поддержку'''''.

= Библиография =
* '''Jeffrey Friedl, Mastering Regular Expressions, O'Reilly and Associates, 2002, 0-596-00289-0'''. 
:''Прекрасное руководство по Регулярным Выражениям''.
* '''Edited by Peter Denning, Computers Under Attack: Intruders, Worms, and Viruses, ACM Press, 1990, 0-201-53067-8'''. 
:''Содержит несколько статей о вирусах, написанных на языке командной оболочки''.
* '''Dale Dougherty and Arnold Robbins, Sed and Awk, 2nd edition, O'Reilly and Associates, 1997, 1-156592-225-5'''. 
:''Чтобы раскрыть всю мощь командной оболочки, вам наверняка потребуется знакомство с sed иawk. Это обычный учебник. Здесь вы найдете превосходное введение в "регулярныевыражения". Обязательно прочитайте эту книгу''.
* '''Chet Ramey and Brian Fox, The GNU Bash Reference Manual, Network Theory Ltd, 2003, 0-9541617-7-7'''. 
:''Это руководство является официальной документацией по GNU Bash. Авторы руководства, ChetRamey и Brian Fox, занимаются разработкой GNU Bash с самого начала. Издатель передаёт $1 в Фонд Свободного Программного Обеспечения (Free Software Foundation) с каждой проданной копии руководства''.
* '''Aeleen Frisch, Essential System Administration, 3rd edition, O'Reilly and Associates, 2002, 0-596-00343-9.'''. 
:''Это замечательное руководство для системных администраторов. Может служить неплохим введением в программирование сценариев. Содержит подробные пояснения к сценариям загрузки и инициализации системы''.
* '''Stephen Kochan and Patrick Woods, Unix Shell Programming, Hayden, 1990, 067248448X'''. 
:''Стандартный справочник, хотя немного устаревший''.
* '''Neil Matthew and Richard Stones, Beginning Linux Programming, Wrox Press, 1996, 1874416680'''. 
:''Даёт хороший, глубокий охват различных языков программирования, доступных в Linux,включая довольно сильную главу по программированию в командной оболочке''.
* '''Herbert Mayer, Advanced C Programming on the IBM PC, Windcrest Books, 1989, 0830693637'''. 
:''Замечательная книга по алгоритмам и практическому программированию''.
* '''David Medinets, Unix Shell Programming Tools, McGraw-Hill, 1999, 0070397333'''. 
:''Отличная книга по программированию в командной оболочке, с примерами, и кратким введением в Tcl и Perl''.
* '''Cameron Newham and Bill Rosenblatt, Learning the Bash Shell, 2nd edition, O'Reilly and Associates, 1998,1-56592-347-2'''. 
:''Это отважная попытка создать учебник для начинающих, но он получился несколько несовершенным, к тому же не изобилует примерами сценариев.''.
* '''Anatole Olczak, Bourne Shell Quick Reference Guide, ASP, Inc., 1991, 093573922X'''. 
:''Очень удобный карманный справочник, несмотря на недостатки, при охвате специфичных свойств Bash''.
* '''Jerry Peek, Tim O'Reilly, and Mike Loukides, Unix Power Tools, 2nd edition, O'Reilly and Associates,Random House, 1997, 1-56592-260-3'''. 
:''Содержит ряд очень информативных разделов, посвященных программированию в командной оболочке, но не может рассматриваться как учебное пособие''.
* '''Clifford Pickover, Computers, Pattern, Chaos, and Beauty, St. Martin's Press, 1990, 0-312-04123-3'''. 
:''Сокровищница идей и рецептов по машинным вычислениям''.
* '''George Polya, How To Solve It, Princeton University Press, 1973, 0-691-02356-5'''. 
:''Классический учебник по методам решения задач''.
* '''Arnold Robbins, Bash Reference Card, SSC, 1998, 1-58731-010-5'''. 
:''Замечательный карманный справочник по Bash. Стоит всего $4.95, но также доступен для свободного скачивания [http://www.ssc.com/ssc/bash/ on-line] в формате PDF''.
* '''Arnold Robbins, Effective Awk Programming, Free Software Foundation / O'Reilly and Associates, 2000, 1-882114-26-4'''. 
:''Самое лучшее учебное руководство и справочник по awk. Свободная электронная версия книги включена в состав документации к [[awk]]. Печатное издание последней версии доступно на сайте O'Reilly and Associates''. '''''Эта книга служила источником вдохновения для автора этой книги'''''.
* '''Bill Rosenblatt, Learning the Korn Shell, O'Reilly and Associates, 1993, 1-56592-054-6'''. 
:''Эта, хорошо написанная книга, содержит массу указаний по созданию сценариев командной оболочки''.
* '''Paul Sheer, LINUX: Rute User's Tutorial and Exposition, 1st edition, , 2002, 0-13-033351-4'''. 
:''Очень хорошее введение в системное администрирование Linux. Эта книга доступна в [https://sourceforge.net/projects/rute/ on-line]''.
* '''Ellen Siever and the staff of O'Reilly and Associates, Linux in a Nutshell, 2nd edition, O'Reilly andAssociates, 1999, 1-56592-585-8'''. 
:''Один из лучших справочников по командам Linux, имеет раздел, посвященный Bash''.
* '''The Unix CD Bookshelf, 3rd edition, O'Reilly and Associates, 2003, 0-596-00392-7'''. 
:''Сборник из 7-ми книг по Unix на CD-ROM. В состав сборника входят такие книги, как Unix PowerTools, Sed and Awk и Learning the Korn Shell. Полный набор необходимых справочных и учебных материалов, который вам только может понадобиться. Стоит примерно $130''. 
Книги издательства O'Reilly, посвящённые '''Perl'''.
* '''Ben Okopnik опубликовал серию отличных статей introductory Bash scripting в выпусках 53, 54,55, 57 и 59 на сайте Linux Gazette, и статью "The Deep, Dark Secrets of Bash" в выпуске 56'''. 
* '''Chet Ramey bash - The GNU Shell — серия статей в 3 и 4 выпусках Linux Journal, Июль-Август 1994.'''. 
* '''Mike G [http://www.tldp.org/HOWTO/Bash-Prog-Intro-HOWTO.html Bash-Programming-Intro HOWTO]'''. 
* '''Richard [http://www.injunea.demon.co.uk/index.htm Unix Scripting Universe]'''. 
* '''Chet Ramey [ftp://ftp.cwru.edu/pub/bash/FAQ/ Bash F.A.Q]'''. 
* '''Ed Schaefer [http://www.unixreview.com/columns/schaefer/ Shell Corner] на [http://networkcomputing.com/ Unix Review]'''. 
* '''Примеры сценариев: [http://alge.anart.no/linux/scripts/ Lucc's Shell Scripts]'''. 
* '''Примеры сценариев: [http://www.shelldorado.com/ SHELLdorado]'''. 
* '''Примеры сценариев: [http://clri6f.gsi.de/gnu/bash-2.01/examples/scripts.noah/ Noah Friedman's script site]'''. 
* '''Steve Parker [https://www.shellscript.sh/ Shell Programming Stuff]'''. 
* '''Примеры сценариев: [https://sourceforge.net/snippet/browse.php?by=lang&lang=7 SourceForge Snippet Library - shell scripts]'''. 
* '''Giles Orr [http://www.tldp.org/HOWTO/Bash-Prompt-HOWTO/ Bash-Prompt HOWTO]'''. 
* '''Замечательное руководство по регулярным выражениям, sed и awk [http://www.grymoire.com/Unix/index.html The Unix Grymoire]'''. 
* '''Eric Pement [http://www.student.northpark.edu/pemente/sed/ sed resources page]'''. 
* '''[https://www.gnu.org/software/gawk/manual/gawk.html The GNU gawk reference manual] (gawk — GNU-версия awk для ОС Linux и BSD)'''. 
* '''Trent Fisher [http://web.cecs.pdx.edu/~trent/gnu/groff/groff.html groff tutorial]'''. 
* '''Mark Komarinski [http://www.tldp.org/HOWTO/Printing-Usage-HOWTO.html Printing-Usage HOWTO]'''. 
* '''Rick Hohensee osimpa — ассемблер для процессора i386, написан полностью на Bash'''. 
* '''Fioretti, Marco, "Scripting for X Productivity," LINUX JOURNAL, Выпуск 113, Сентябрь, 2003, стр.86-9'''. 
* '''Aurelio Marinho Jargas написал [http://aurelio.net/projects/txt2regex/ Regular expression wizard]. Он так же написал поучительную [http://aurelio.net/regex/guia/ книгу], посвященную регулярным выражениям, на португальском(!) языке.'''. 
* '''Ben Tomkins создал [http://bashnavigator.sourceforge.net/ Bash Navigator] — средство навигации по каталогам'''. 
* '''William Park работает над проектом по переносу некоторых возможностей из Awk и Python в Bash'''. 
* '''Rocky Bernstein ведет разработку "полнофункционального" [http://bashdb.sourceforge.net/ отладчика] для Bash.'''. 
* '''Отличное руководство "Bash Reference Manual", авторы Chet Ramey и Brian Fox,распространяется в составе пакета "bash-2-doc" (доступен как rpm). В этом пакете вы найдёте особенно поучительные примеры.'''. 
* '''Группа новостей comp.os.unix.shell'''. 
* '''Страницы руководства man по bash и bash2, date, expect, expr, find, grep, gzip, ln, patch,tar, tr, bc, xargs. Странички info по bash, dd, m4, gawk и sed'''. 

= Приложение А. Дополнительные примеры сценариев =
В этом приложении собраны сценарии, которые не попали в основной текст документа. Однако, они определенно стоят того, что бы вы потратили время на их изучение.
 '''Пример''': '''''A-1. manview: Просмотр страниц руководств man.'''''
<source lang="bash">
#!/bin/bash
# manview.sh: Просмотр страниц руководств man в форматированном виде.

# Полезен писателям страниц руководств, позволяет просмотреть страницы в исходном коде
# как они будут выглядеть в конечном виде.

E_WRONGARGS=65

if [ -z "$1" ]
then
echo "Порядок использования: `basename $0` имя_файла"
exit $E_WRONGARGS
fi

groff -Tascii -man $1 | less
# Если страница руководства включает в себя таблицы и/или выражения,
# то этот сценарий "стошнит".
# Для таких случаев можно использовать следующую строку.
#
#gtbl < "$1" | geqn -Tlatin1 | groff -Tlatin1 -mtty-char -man
#
# Спасибо S.C.

exit 0
</source> 
 '''Пример''': '''''A-2. mailformat: Форматирование электронных писем.'''''
<source lang="bash">
#!/bin/bash
# mail-format.sh: Форматирование электронных писем.

# Удаляет символы "^", табуляции и ограничивает чрезмерно длинные строки.

# =================================================================
# Стандартная проверка аргументов
ARGS=1
E_BADARGS=65
E_NOFILE=66

if [ $# -ne $ARGS ] # Проверка числа аргументов
then
echo "Порядок использования: `basename $0` имя_файла"
exit $E_BADARGS
fi

if [ -f "$1" ] # Проверка наличия файла.
then
file_name=$1
else
echo "Файл \"$1\" не найден."
exit $E_NOFILE
fi
# =================================================================

MAXWIDTH=70 # Максимальная длина строки.

# Удаление символов "^" начиная с первого символа строки,
# и ограничить длину строки 70-ю символами.
sed '
s/^>//
s/^ *>//
s/^ *//
s/ *//
' $1 | fold -s --width=$MAXWIDTH
# ключ -s команды "fold" разрывает, если это возможно, строку по пробельному символу.
# Этот сценарий был написан после прочтения статьи, в котором расхваливалась
# утилита под Windows, размером в 164K, с подобной функциональностью.
#
# Хороший набор утилит для обработки текста и эффективный
# скриптовый язык — это всё, что необходимо, чтобы составить серьезную конкуренцию
# чрезмерно "раздутым" программам.

exit 0
</source> 
 '''Пример''': '''''A-3. rn: Очень простая утилита для переименования файлов.'''''
<source lang="bash">
#!/bin/bash
# Очень простая утилита для переименования файлов
#
# Утилита "ren", автор Vladimir Lanin (lanin@csd2.nyu.edu),
# выполняет эти же действия много лучше.

ARGS=2
E_BADARGS=65
ONE=1 # Единственное или множественное число (см. ниже).

if [ $# -ne "$ARGS" ]
then
echo "Порядок использования: `basename $0` старый_шаблон новый_шаблон"
# Например: "rn gif jpg", поменяет расширения всех файлов в текущем каталоге с gif на jpg.
exit $E_BADARGS
fi

number=0 # Количество переименованных файлов.

for filename in *$1* # Проход по списку файлов в текущем каталоге.
do
if [ -f "$filename" ]
then
fname=`basename $filename` # Удалить путь к файлу из имени.
n=`echo $fname | sed -e "s/$1/$2/"` # Поменять старое имя на новое.
mv $fname $n # Переименовать.
let "number += 1"
fi
done

if [ "$number" -eq "$ONE" ] # Соблюдение правил грамматики.
then
echo "$number файл переименован."
else
echo "Переименовано файлов: $number."
fi

exit 0

# Упражнения:
# ----------
# С какими типами файлов этот сценарий не будет работать?
# Как это исправить?
#
# Переделайте сценарий таким образом, чтобы он мог обрабатывать все файлы в каталоге,
# в именах которых содержатся пробелы, заменяя пробелы символом подчеркивания.
</source> 
 '''Пример''': '''''A-4. blank-rename: переименование файлов, чьи имена содержат пробелы.'''''
Это даже более простая версия предыдущего примера.
<source lang="bash">
#! /bin/bash
# blank-rename.sh
#
# Заменяет пробелы символом подчеркивания в именах файлов в текущем каталоге.

ONE=1 # единственное или множественное число (см. ниже).
number=0 # Количество переименованных файлов.
FOUND=0 # Код завершения в случае успеха.

for filename in * # Перебор всех файлов в текущем каталоге.
do
echo "$filename" | grep -q " " # Проверить — содержит ли имя файла
if [ $? -eq $FOUND ] # пробелы.
then
fname=$filename # Удалить путь из имени файла.
n=`echo $fname | sed -e "s/ /_/g"` # Заменить пробелы символом подчеркивания.
mv "$fname" "$n" # Переименование.
let "number += 1"
fi
done

if [ "$number" -eq "$ONE" ]
then
echo "$number файл переименован."
else
echo "Переименовано файлов: $number"
fi

exit 0
</source> 
 '''Пример''': '''''A-5. encryptedpw: Передача файла на ftp-сервер, с использованием пароля.'''''
<source lang="bash">
#!/bin/bash
# Модификация примера "ex72.sh", добавлено шифрование пароля.

# Обратите внимание: этот вариант всё еще нельзя считать безопасным,
# поскольку в сеть пароль уходит в незашифрованном виде.
# Используйте "ssh", если вас это беспокоит.

E_BADARGS=65

if [ -z "$1" ]
then
echo "Порядок использования: `basename $0` имя_файла"
exit $E_BADARGS
fi

Username=bozo # Измените на свой.
pword=/home/bozo/secret/password_encrypted.file
# Файл, содержащий пароль в зашифрованном виде.

Filename=`basename $1` # Удалить путь из имени файла

Server="XXX"
Directory="YYY" # Подставьте фактические имя сервера и каталога.

Password=`cruft <$pword` # Расшифровка.
# Используется авторская программа "cruft",
# основанная на алгоритме "onetime pad",
# её можно скачать с :
# Primary-site: ftp://ibiblio.org/pub/Linux/utils/file
# cruft-0.2.tar.gz [16k]

ftp -n $Server <<End-Of-Sessionuser
$Username $Password
binary
bell
cd $Directory
put $Filename
bye
End-Of-Session
# ключ -n, команды "ftp", запрещает автоматический вход.
# "bell" — звонок (звуковой сигнал) после передачи каждого файла.

exit 0
</source> 
 '''Пример''': '''''A-6. copy-cd: Копирование компакт-дисков с данными.'''''
<source lang="bash">
#!/bin/bash
# copy-cd.sh: copying a data

CDCDROM=/dev/cdrom # устройство CD-ROM
OF=/home/bozo/projects/cdimage.iso # промежуточный файл
# /xxxx/xxxxxxx/ измените для своей системы.
BLOCKSIZE=2048
SPEED=2 # Можно задать более высокую скорость, если поддерживается.

echo; echo "Вставьте исходный CD, но *НЕ* монтируйте его."
echo "Нажмите ENTER, когда будете готовы. "
read ready # Ожидание.

echo; echo "Создаётся промежуточный файл $OF."
echo "Это может занять какое-то время. Пожалуйста, подождите."

dd if=$CDROM of=$OF bs=$BLOCKSIZE # Копирование.

echo; echo "Выньте исходный CD."
echo "Вставьте чистую болванку CD-R."
echo "Нажмите ENTER, когда будете готовы. "
read ready # Ожидание.

echo "Копируется файл $OF на болванку."

cdrecord -v -isosize speed=$SPEED dev=0,0 $OF
# Используется пакет Joerg Schilling — "cdrecord".
# http://www.fokus.gmd.de/nthp/employees/schilling/cdrecord.html

echo; echo "Копирование завершено."

echo "Желаете удалить промежуточный файл (y/n)? " # Наверняка большой файл получился.
read answer

case "$answer"
in[yY]) rm -f $OF; echo "Файл $OF удален.";;
*) echo "Файл $OF не был удален.";;
esac

echo

# Упражнение:
# Добавьте в оператор "case" возможность обработки, введенных пользователем, "yes" и "Yes".
exit 0
</source> 
 '''Пример''': '''''A-7. Последовательности Коллаца (Collatz).'''''
<source lang="bash">
#!/bin/bash
# collatz.sh

# Широко известная последовательность Коллаца (Collatz) (гипотеза Коллаца).
# -------------------------------------------
# 1) Принимает из командной строки "начальное" целое число.
# 2) ЧИСЛО <--- НАЧАЛЬНОЕ ЗНАЧЕНИЕ
# 3) Вывести ЧИСЛО.
# 4) Если ЧИСЛО чётное, разделить на 2,
# 5) Если не чётное — умножить на 3 и прибавить 1.
# 6) ЧИСЛО <--- РЕЗУЛЬТАТ
# 7) Повторить, начиная с п. 3, заданное число раз.
#
# Теоретически, такая последовательность должна сходиться,
# не зависимо от величины начального значения,
# к повторению циклов "4,2,1...",
# даже после значительных флуктуаций в самом начале.

MAX_ITERATIONS=200
# Для больших начальных значений (>32000), это значение придется увеличить.
h=${1:-$$} # Начальное значение
# если из командной строки ничего не задано, то берется $PID,
echo
echo "C($h) --- $MAX_ITERATIONS итераций"
echo

for ((i=1; i<=MAX_ITERATIONS; i++))
do
echo -n "$h "
# ^^^^^
# табуляция
let "remainder = h % 2"
if [ "$remainder" -eq 0 ] # Чётное?
then
let "h /= 2" # Разделить на 2.
else # Иначе
let "h = h*3 + 1" # Умножить на 3 и прибавить 1.
fi

COLUMNS=0 # Выводить по 10 значений в строке.
let "line_break = i % $COLUMNS"
if [ "$line_break" -eq 0 ]
then
echo
fi
done

echo

exit 0
</source> 
 '''Пример''': '''''A-8. days-between: Подсчет числа дней между двумя датами.'''''
<source lang="bash">
#!/bin/bash
# days-between.sh: Подсчёт числа дней между двумя датами.

# Порядок использования: ./days-between.sh [M]M/[D]D/YYYY [M]M/[D]D/YYYY

ARGS=2 # Ожидается два аргумента из командной строки.
E_PARAM_ERR=65 # Ошибка в числе ожидаемых аргументов.

REFYR=1600 # Начальный год.

CENTURY=100
DIY=365
ADJ_DIY=367 # Корректировка на високосный год + 1.
MIY=12
DIM=31
LEAPCYCLE=4

MAXRETVAL=255 # Максимально возможное возвращаемое значение для положительных чисел.

diff= # Количество дней между датами.
value= # Абсолютное значение.
day= # день, месяц, год.
month=
year=

Param_Error () # Ошибка в параметрах командной строки.
{
echo "Порядок использования: `basename $0` [M]M/[D]D/YYYY [M]M/[D]D/YYYY"
echo " (даты должны быть после 1/3/1600)"
exit $E_PARAM_ERR
}

Parse_Date () # Разбор даты.
{
month=${1%%/**}
dm=${1%/**} # День и месяц.
day=${dm#*/}
let "year = `basename $1`" # Хотя это и не имя файла, но результат тот же.
}

check_date () # Проверка даты.
{
[ "$day" -gt "$DIM" ] || [ "$month" -gt "$MIY" ] || [ "$year" -lt "$REFYR" ] && Param_Error
# Выход из сценария при обнаружении ошибки.
# Используется комбинация "ИЛИ-списка / И-списка".
#
# Упражнение: Реализуйте более строгую проверку даты.
}

strip_leading_zero () # Удалить ведущий ноль
{
val=${1#0} # иначе Bash будет считать числа
return $val # восьмеричными (POSIX.2, sect 2.9.2.1).
}

day_index () # Формула Гаусса:
{ # Количество дней от 3 Янв. 1600 до заданной даты.
day=$1
month=$2
year=$3

let "month = $month - 2"
if [ "$month" -le 0 ]
then
let "month += 12"
let "year -= 1"
fi

let "year -= $REFYR"
let "indexyr = $year / $CENTURY"

let "Days = $DIY*$year + $year/$LEAPCYCLE - $indexyr + $indexyr/$LEAPCYCLE + $ADJ_DIY*$month/$MIY + $day - $DIM"
# Более подробное объяснение алгоритма вы найдете в
# http://home.t-online.de/home/berndt.schwerdtfeger/cal.htm

if [ "$Days" -gt "$MAXRETVAL" ] # Если больше 255,
then # то поменять знак
let "dindex = 0 - $Days" # чтобы функция смогла вернуть полное значение.
else let "dindex = $Days"
fi

return $dindex
}

calculate_difference () # Разница между двумя датами.
{
let "diff = $1 - $2" # Глобальная переменная.
}

abs () # Абсолютное значение
{ # Используется глобальная переменная "value".
if [ "$1" -lt 0 ] # Если число отрицательное,
then # то
let "value = 0 - $1" # изменить знак,
else # иначе
let "value = $1" # оставить как есть.
fi
}

if [ $# -ne "$ARGS" ] # Требуется два аргумента командной строки.
then
Param_Error
fi

Parse_Date $1
check_date $day $month $year # Проверка даты.
strip_leading_zero $day # Удалить ведущие нули
day=$? # в номере дня и/или месяца.
strip_leading_zero $month
month=$?

day_index $day $month $year
date1=$?

abs $date1 # Абсолютное значение
date1=$value

Parse_Date $2
check_date $day $month $yearstrip_leading_zero $day
day=$?

strip_leading_zero $month
month=$?

day_index $day $month $year
date2=$?

abs $date2 # Абсолютное значение
date2=$value

calculate_difference $date1 $date2

abs $diff # Абсолютное значение
diff=$value

echo $diff

exit 0
# Сравните этот сценарий с реализацией формулы Гаусса на C
# http://buschencrew.hypermart.net/software/datedif
</source> 

 '''Пример''': '''''A-9. Создание "словаря".'''''
<source lang="bash">
#!/bin/bash
# makedict.sh [создание словаря]

# Модификация сценария /usr/sbin/mkdict.
# Авторские права на оригинальный сценарий принадлежат Alec Muffett.
#
# Этот модифицированный вариант включен в документ на основе
# документа "LICENSE" из пакета "Crack"
# с которым распространяется оригинальный сценарий.

# Этот скрипт обрабатывает текстовые файлы и создаёт отсортированный список
# слов, найденных в этих файлах.

# Он может оказаться полезным для сборки словарей
# и проведения лексикографического анализа.

E_BADARGS=65

if [ ! -r "$1" ] # Необходим хотя бы один аргумент --
then # имя файла.
echo "Порядок использования: $0 имена_файлов"
exit $E_BADARGS
fi

# SORT="sort" # Необходимость задания ключей сортировки отпала.
# Изменено, по отношению к оригинальному сценарию.

cat $* | # Выдать содержимое файлов на stdout.
tr A-Z a-z | # Преобразовать в нижний регистр.
tr ' ' '\012' | # Новое: заменить пробелы символами перевода строки.
# tr -cd '\012[a-z][0-9]' | # В оригинальном сценарии: удалить все символы,
# которые не являются буквами или цифрами.
tr -c '\012a-z' '\012' | # Вместо удаления
# не алфавитно-цифровые символы заменяются на перевод строки.
sort |
uniq | # Удалить повторяющиеся слова.
grep -v '^#' | # Удалить строки, начинающиеся с "#".
grep -v '^$' # Удалить пустые строки.
exit 0
</source> 
 '''Пример''': '''''A-10. Расчет индекса "созвучности".'''''
<source lang="bash">
#!/bin/bash
# soundex.sh: Расчет индекса "созвучности"

# =======================================================
# Сценарий Soundex
# Автор
# Mendel Cooper
# thegrendel@theriver.com
# 23 Января 2002 г.
#
# Условия распространения: Public Domain.
#
# Несколько отличающаяся версия этого сценария была опубликована
# Эдом Шэфером (Ed Schaefer) в Июле 2002 года в колонке "Shell Corner"
# "Unix Review" on-line,
# http://www.unixreview.com/documents/uni1026336632258/
# =======================================================

ARGCOUNT=1 # Требуется аргумент командной строки.
E_WRONGARGS=70

if [ $# -ne "$ARGCOUNT" ]
then
echo "Порядок использования: `basename $0` имя"
exit $E_WRONGARGS
fi

assign_value () # Присвоить числовые значения
{ # символам в имени.
val1=bfpv # 'b,f,p,v' = 1
val2=cgjkqsxz # 'c,g,j,k,q,s,x,z' = 2
val3=dt # и т.п.
val4=l
val5=mn
val6=r
# Попробуйте разобраться в том, что здесь происходит.

value=$( echo "$1" \
| tr -d wh \
| tr $val1 1 | tr $val2 2 | tr $val3 3 \
| tr $val4 4 | tr $val5 5 | tr $val6 6 \
| tr -s 123456 \
| tr -d aeiouy )

# Символам в имени присваиваются числовые значения.
# Удаляются повторяющиеся числа, если они не разделены гласными.
# Гласные игнорируются, если они не являются разделителями, которые удаляются в последнюю очередь.
# Символы 'w' и 'h' удаляются в первую очередь.
}

input_name="$1"
echo
echo "Имя = $input_name"

# Перевести все символы в имени в нижний регистр.
# ------------------------------------------------
name=$( echo $input_name | tr A-Z a-z )
# ------------------------------------------------

# Начальный символ в индекса "созвучия": первая буква в имени.
# --------------------------------------------

char_pos=0 # Начальная позиция в имени.
prefix0=${name:$char_pos:1}
prefix=`echo $prefix0 | tr a-z A-Z` # Первую букву в имени — в верхний регистр.
let "char_pos += 1" # Передвинуть "указатель" на один символ.
name1=${name:$char_pos}

# ++++++++++++++++++++++++++++ Исключение отдельных ситуаций +++++++++++++++++++++++++++++++
# Теперь мы передвинулись на один символ вправо.
# Если второй символ в имени совпадает с первым
# то его нужно отбросить.
# Кроме того, мы должны проверить не является ли первый символ
# гласной, 'w' или 'h'.

char1=`echo $prefix | tr A-Z a-z` # Первый символ -- в нижний регистр.
assign_value $name
s1=$value
assign_value $name1
s2=$value
assign_value $char1
s3=$value
s3=9$s3 # Если первый символ в имени — гласная буква
# или 'w' или 'h',
# то её "значение" нужно отбросить.
# Поэтому ставим 9, или другое
# неиспользуемое значение, которое можно будет проверить.

if [[ "$s1" -ne "$s2" || "$s3" -eq 9 ]]
then
suffix=$s2
else
suffix=${s2:$char_pos}
fi
# ++++++++++++++++++++++++ Конец исключения отдельных ситуаций +++++++++++++++++++++++++++++++

padding=000 # Дополнить тремя нулями.

soun=$prefix$suffix$padding # Нули добавить в конец получившегося индекса.

MAXLEN=4 # Ограничить длину индекса 4-мя символами.
soundex=${soun:0:$MAXLEN}

echo "Индекс созвучия = $soundex"

echo

# Индекс "созвучия" - это метод индексации и классификации имён
# по подобию звучания.
# Индекс "созвучия" начинается с первого символа в имени,
# за которым следуют 3-значный расчетный код.
# Имена, которые произносятся примерно одинаково, имеют близкие индексы "созвучия".

# Например:
# Smith и Smythe — оба имеют индекс "созвучия" "S530".
# Harrison = H625
# Hargison = H622
# Harriman = H655
# Как правило эта методика дает неплохой результат, но имеются и аномалии.
#
#
#
# Дополнительную информацию вы найдете на
# "National Archives and Records Administration home page",
# http://www.nara.gov/genealogy/soundex/soundex.html

# Упражнение:
# ----------
# Упростите блок "Исключение отдельных ситуаций".

exit 0
</source> 
 '''Пример''': '''''A-11. "Игра "Жизнь".'''''
<source lang="bash">
#!/bin/bash
# life.sh: Игра "Жизнь"

# ##################################################################### #
# Это Bash-версия известной игры Джона Конвея (John Conway) "Жизнь". #
# #
# --------------------------------------------------------------------- #
# Прямоугольное игровое поле разбито на ячейки, в каждой ячейке может #
# располагаться живая особь. #
# Соответственно, ячейка с живой особью отмечается точкой, #
# не занятая ячейка — остаётся пустой. #
# Изначально, ячейки заполняются из файла — #
# это первое поколение, или "поколение 0" #
# Воспроизводство особей, в каждом последующем поколении, #
# определяется следующими правилами #
# 1) Каждая ячейка имеет "соседей" #
# слева, справа, сверху, снизу и 4 по диагоналям. #
# 123 #
# 4*5 #
# 678 #
# #
# 2) Если живая особь имеет 2 или 3 живых соседей, то она остаётся жить.#
# 3) Если пустая ячейка имеет 3 живых соседей — #
# в ней "рождается" новая особь #
SURVIVE=2 #
BIRTH=3 #
# 4) В любом другом случае, живая особь "погибает" #
# ##################################################################### #

startfile=gen0 # Начальное поколение из файла по-умолчанию — "gen0".
# если не задан другой файл, из командной строки.
#
if [ -n "$1" ] # Проверить аргумент командной строки — файл с "поколением 0".
then
if [ -e "$1" ] # Проверка наличия файла.
then
startfile="$1"
fi
fi

ALIVE1=.
DEAD1=_
# Представление "живых" особей и пустых ячеек в файле с "поколением 0".

# Этот сценарий работает с игровым полем 10 x 10 grid (может быть увеличено,
# но большое игровое поле будет обрабатываться очень медленно).

ROWS=10
COLS=10

GENERATIONS=10 # Максимальное число поколений.

NONE_ALIVE=80 # Код завершения на случай,
# если не осталось ни одной "живой" особи.

TRUE=0
FALSE=1
ALIVE=0
DEAD=1

avar= # Текущее поколение.
generation=0 # Инициализация счетчика поколений.
# =================================================================

let "cells = $ROWS * $COLS" # Количество ячеек на игровом поле.
declare -a initial # Массивы ячеек.
declare -a current

display ()
{
alive=0 # Количество "живых" особей.
# Изначально — ноль.
declare -a arr
arr=( `echo "$1"` ) # Преобразовать аргумент в массив.

element_count=${#arr[*]}

local i
local rowcheck

for ((i=0; i<$elementcount; i++))
do
# Символ перевода строки — в конец каждой строки.
let "rowcheck = $i % ROWS"
if [ "$rowcheck" -eq 0 ]
then
echo # Перевод строки.
echo -n " " # Выравнивание.
fi

cell=${arr[i]}

if [ "$cell" = . ]
then
let "alive += 1"
fi

echo -n "$cell" | sed -e 's/_/ /g'
# Вывести массив, по пути заменяя символы подчеркивания на пробелы.
done

return
}

IsValid () # Проверка корректности координат ячейки.
{
if [ -z "$1" -o -z "$2" ] # Проверка наличия входных аргументов.
then
return $FALSE
fi
local row
local lower_limit=0 # Запрет на отрицательные координаты.
local upper_limit
local leftlocal right

let "upper_limit = $ROWS * $COLS - 1" # Номер последней ячейки на игровом поле.

if [ "$1" -lt "$lower_limit" -o "$1" -gt "$upper_limit" ]
then
return $FALSE # Выход за границы массива.
fi

row=$2
let "left = $row * $ROWS" # Левая граница.
let "right = $left + $COLS - 1" # Правая граница.

if [ "$1" -lt "$left" -o "$1" -gt "$right" ]
then
return $FALSE # Выход за нижнюю строку.
fi

return $TRUE # Координаты корректны.
}

IsAlive () # Проверка наличия "живой" особи в ячейке.
# Принимает массив и номер ячейки в качестве входных аргументов.
{
GetCount "$1" $2 # Подсчитать кол-во "живых" соседей.
local nhbd=$?

if [ "$nhbd" -eq "$BIRTH" ] # "Живая".
then
return $ALIVE
fi

if [ "$3" = "." -a "$nhbd" -eq "$SURVIVE" ]
then # "Живая" если перед этим была "живая".
return $ALIVE
fi

return $DEAD # По-умолчанию.
}

GetCount () # Подсчёт "живых" соседей.
# Необходимо 2 аргумента:
# $1) переменная-массив
# $2) cell номер ячейки
{
local cell_number=$2
local array
local top
local center
local bottom
local r
local row
local i
local t_top
local t_cen
local t_bot
local count=0
local ROW_NHBD=3

array=( `echo "$1"` )

let "top = $cell_number - $COLS - 1" # Номера соседних ячеек.
let "center = $cell_number - 1"
let "bottom = $cell_number + $COLS - 1"
let "r = $cell_number / $ROWS"

for ((i=0; i<$ROW_NHBD; i++)) # Просмотр слева-направо.
do
let "t_top = $top + $i"
let "t_cen = $center + $i"
let "t_bot = $bottom + $i"

let "row = $r" # Пройти по соседям в средней строке.
IsValid $t_cen $row # Координаты корректны?
if [ $? -eq "$TRUE" ]
then
if [ ${array[$t_cen]} = "$ALIVE1" ] # "Живая"?
then # Да!
let "count += 1" # Нарастить счётчик.
fi
fi

let "row = $r - 1" # По верхней строке.
IsValid $t_top $row
if [ $? -eq "$TRUE" ]
then
if [ ${array[$t_top]} = "$ALIVE1" ]
then
let "count += 1"
fi
fi

let "row = $r + 1" # По нижней строке.
IsValid $t_bot $row
if [ $? -eq "$TRUE" ]
then
if [ ${array[$t_bot]} = "$ALIVE1" ]
then
let "count += 1"
fi
fi

done

if [ ${array[$cell_number]} = "$ALIVE1" ]
then
let "count -= 1" # Убедиться, что сама проверяемая ячейка
fi # не была подсчитана.

return $count

}

next_gen () # Обновить массив, в котором содержится информация о новом "поколении".
{
local array
local i=0

array=( `echo "$1"` ) # Преобразовать в массив.

while [ "$i" -lt "$cells" ]
do
IsAlive "$1" $i ${array[$i]} # "Живая"?
if [ $? -eq "$ALIVE" ]
then # Если "живая", то
array[$i]=. # записать точку.
else
array[$i]="_" # Иначе — символ подчеркивания
fi # (который позднее заменится на пробел).
let "i += 1"
done

# let "generation += 1" # Увеличить счетчик поколений.

# Подготовка переменных, для передачи в функцию "display".
avar=`echo ${array[@]}` # Преобразовать массив в строку.
display "$avar" # Вывести его.
echo; echo
echo "Поколение $generation — живых особей $alive"

if [ "$alive" -eq 0 ]
then
echo
echo "Преждевременное завершение: не осталось ни одной живой особи!"
exit $NONE_ALIVE # Нет смысла продолжать
fi # если не осталось ни одной живой особи
}

# =========================================================

# main ()

# Загрузить начальное поколение из файла.
initial=( `cat "$startfile" | sed -e '/#/d' | tr -d '\n' |\
sed -e 's/\./\. /g' -e 's/_/_ /g'` )
# Удалить строки, начинающиеся с символа '#' — комментарии.
# Удалить строки перевода строки и вставить пробелы между элементами.

clear # Очистка экрана.

echo # Заголовок
echo "======================="
echo " $GENERATIONS поколений"
echo " в"
echo " игре \" ЖИЗНЬ\""
echo "======================="

# -------- Вывести первое поколение. --------
Gen0=`echo ${initial[@]}`
display "$Gen0" # Только вывод.
echo; echo
echo "Поколение $generation — живых особей $alive"
# -------------------------------------------

let "generation += 1" # Нарастить счётчик поколений.
echo

# ------- Вывести второе поколение. -------
Cur=`echo ${initial[@]}`
next_gen "$Cur" # Обновить и вывести.
# ------------------------------------------

let "generation += 1" # Нарастить счётчик поколений.

# ------ Основной цикл игры ------
while [ "$generation" -le "$GENERATIONS" ]
do
Cur="$avar"
next_gen "$Cur"
let "generation += 1"
done

# ==============================================================
echo

exit 0

# --------------------------------------------------------------
# Этот сценарий имеет недоработку.
# Граничные ячейки сверху, снизу и с боков остаются пустыми.
# Упражнение: Доработайте сценарий таким образом, чтобы
# левая и правая стороны как бы "соприкасались",
# так же и верхняя и нижняя стороны.
</source> 
 '''Пример''': '''''A-12. Файл с первым поколением для игры "Жизнь".'''''
<source lang="bash">
# Это файл-пример, содержащий "поколение 0", для сценария "life.sh".
# --------------------------------------------------------------
# Игровое поле имеет размер 10 x 10, точкой обозначается "живая" особь,
# символом подчеркивания — пустая ячейка. Мы не можем использовать пробелы,
# для обозначения пустых ячеек, из-за особенностей строения массивов в Bash.
# [Упражнение для читателей: объясните, почему?]
#
# Строки, начинающиеся с символа '#' считаются комментариями, сценарий их игнорирует.
__.__..___
___._.____
____.___..
_._______.
____._____
..__...___
____._____
___...____
__.._..___
_..___..__
+++
</source> 
Следующие два сценария предоставил ''Mark Moraes'', из университета в Торонто. См. файл "Moraes-COPYRIGHT", который содержит указание на авторские права.
 '''Пример''': '''''A-13. behead: Удаление заголовков из электронных писем и новостей.'''''
<source lang="bash">
#! /bin/sh
# Удаление заголовков из электронных писем и новостей т.е. до первой
# пустой строки# Mark Moraes, Университет в Торонто

# ==> Такие комментарии добавлены автором документа.

if [ $# -eq 0 ]; then
# ==> Если входной аргумент не задан (файл), то выводить результат на stdin.
sed -e '1,/^$/d' -e '/^[ ]*$/d'
# --> Удалить пустые строки и все строки предшествующие им
else
# ==> Если аргумент командной строки задан, то использовать его как имя файла.
for i do
sed -e '1,/^$/d' -e '/^[ ]*$/d' $i
# --> То же, что и выше.
done
fi
# ==> Упражнение: Добавьте проверку на наличие ошибок.
# ==>
# ==> Обратите внимание — как похожи маленькие сценарии sed, за исключением передачи аргумента.
# ==> Можно ли его оформит в виде функции? Почему да или почему нет?
</source> 
 '''Пример''': '''''A-14. ftpget: Скачивание файлов по ftp.'''''
<source lang="bash">
#! /bin/sh
# $Id: ftpget,v 1.2 91/05/07 21:15:43 moraes Exp $
# Сценарий устанавливает анонимное соединение с ftp-сервером.
# Простой и быстрый - написан как дополнение к ftplist
# -h — удалённый сервер (по-умолчанию prep.ai.mit.edu)
# -d -- каталог на сервере - вы можете указать последовательность из нескольких ключей -d\
# Если вы используете относительные пути,
# будьте внимательны при задании последовательности.
# (по-умолчанию — каталог пользователя ftp)
# -v — "многословный" режим, будет показывать все ответы ftp-сервера
# -f — file[:localfile] скачивает удаленный file и записывает под именем localfile
# -m — шаблон для mget. Не забудьте взять в кавычки!
# -c — локальный каталог# Например,
# ftpget -h expo.lcs.mit.edu -d contrib -f xplaces.shar:xplaces.sh \
# -d ../pub/R3/fixes -c ~/fixes -m 'fix*'
# Эта команда загрузит файл xplaces.shar из ~ftp/contrib с expo.lcs.mit.edu
# и сохранит под именем xplaces.sh в текущем каталоге, затем заберет все исправления (fixes)
# из ~ftp/pub/R3/fixes и поместит их в каталог ~/fixes.
# Очевидно, что последовательность ключей и аргументов очень важна, поскольку
# она определяет последовательность операций, выполняемых с удаленным ftp-сервером
#
# Mark Moraes (moraes@csri.toronto.edu), Feb 1, 1989
#

# ==> Эти комментарии добавлены автором документа.

# PATH=/local/bin:/usr/ucb:/usr/bin:/bin
# export PATH
# ==> Первые две строки в оригинальном сценарии вероятно излишни.

TMPFILE=/tmp/ftp.$$

# ==> Создан временный файл
SITE=`domainname`.toronto.edu
# ==> 'domainname' подобен 'hostname'
usage="Порядок использования: $0 [-h удаленный_сервер] [-d удаленный_каталог]... [-f удаленный_файл:локальный_файл]... \
[-c локальный_каталог] [-m шаблон_имен_файлов] [-v]"
ftpflags="-i -n"
verbflag=
set -f # разрешить подстановку имен файлов (globbing) для опции -m
set x `getopt vh:d:c:m:f: $*`
if [ $? != 0 ]; then
echo $usage
exit 65
fi
shift
trap 'rm -f ${TMPFILE} ; exit' 0 1 2 3 15
echo "user anonymous ${USER-gnu}@${SITE} > ${TMPFILE}"
# ==> Добавлены кавычки (рекомендуется).
echo binary >> ${TMPFILE}
for i in $* # ==> Разбор командной строки.
do
case $i in
-v) verbflag=-v; echo hash >> ${TMPFILE}; shift;;
-h) remhost=$2; shift 2;;
-d) echo cd $2 >> ${TMPFILE};
if [ x${verbflag} != x ]; then
echo pwd >> ${TMPFILE};
fi;
shift 2;;
-c) echo lcd $2 >> ${TMPFILE}; shift 2;;
-m) echo mget "$2" >> ${TMPFILE}; shift 2;;
-f) f1=`expr "$2" : "$[^:]*$.*"`; f2=`expr "$2" : "[^:]*:$.*$"`;
echo get ${f1} ${f2} >> ${TMPFILE}; shift 2;;
--) shift; break;;
esac
done

if [ $# -ne 0 ]; then
echo $usage
exit 65 # ==> В оригинале было "exit 2", изменено в соответствии со стандартами.
fi

if [ x${verbflag} != x ]; then
ftpflags="${ftpflags} -v"
fi

if [ x${remhost} = x ]; then
remhost=prep.ai.mit.edu
# ==> Здесь можете указать свой ftp-сервер по-умолчанию.
fi

echo quit >> ${TMPFILE}
# ==> Все команды сохранены во временном файле.
ftp ${ftpflags} ${remhost} < ${TMPFILE}
# ==> Теперь обработать пакетный файл.

rm -f ${TMPFILE}
# ==> В заключение, удалить временный файл (можно скопировать его в системный журнал).

# ==> Упражнения:
# ==> ----------
# ==> 1) Добавьте обработку ошибок.
# ==> 2) Добавьте уведомление звуковым сигналом.
</source> 
 '''Пример''': '''''A-15. Указание на авторские права.'''''
<source lang="bash">
Следующее соглашение об авторских правах относится к двум, включенным в книгу,сценариям от Mark Moraes: "behead.sh" и "ftpget.sh"
/*
* Copyright University of Toronto 1988, 1989.
* Автор: Mark Moraes
*
* Автор даёт право на использование этого программного обеспечения
* его изменение и распространение со следующими ограничениями:
*
* 1. Автор и Университет Торонто не отвечают за
* последствия использования этого программного
* обеспечения, какими ужасными бы они ни были,
* даже если эти последствия вызваны ошибками
* в данном программном обеспечении.
*
* 2. Указание на происхождение программного обеспечения
* не должно подвергаться изменениям, явно или по
* оплошности. Так как некоторые пользователи обращаются
* к исходным текстам, они обязательно должны быть
* включены в состав документа.
*
* 3. Измененная версия должна содержать явное упоминание
* об этом и не должна выдаваться за оригинал.
* Так как некоторые пользователи обращаются к исходным текстам,
* они обязательно должны быть включены в состав документа.
*
* 4. Это соглашение не может удаляться и/или изменяться.
*/
</source> 
<big>+</big> 
Antek Sawicki предоставил следующий сценарий, который демонстрирует операцию подстановки параметров.
 '''Пример''': '''''A-16. password: Генератор случайного 8-ми символьного пароля.'''''
<source lang="bash">
#!/bin/bash
# Для старых систем может потребоваться указать #!/bin/bash2.
#
# Генератор случайных паролей для bash 2.x
# Автор: Antek Sawicki <tenox@tenox.tc>,
# который великодушно позволил использовать его в данном документе.
#
#==> Комментарии, добавленные автором документа ==>

MATRIX="0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
LENGTH="8"
# ==> 'LENGTH' можно увеличить, для генерации более длинных паролей.

while [ "${n:=1}" -le "$LENGTH" ]
# ==> Напоминаю, что ":=" — это оператор "подстановки значения по-умолчанию".
# ==> Таким образом, если 'n' не инициализирована, то в неё заносится 1.
do
PASS="$PASS${MATRIX:$(($RANDOM%${#MATRIX})):1}"
# ==> Хитро, хитро....

# ==> Начнём с самых внутренних скобок...
# ==> ${#MATRIX} — возвращает длину массива MATRIX.
# ==> $RANDOM%${#MATRIX} — возвращает случайное число
# ==> в диапазоне 1 .. ДЛИНА_МАССИВА(MATRIX) - 1.

# ==> ${MATRIX:$(($RANDOM%${#MATRIX})):1}
# ==> возвращает символ из MATRIX, из случайной позиции (найденной выше).
# ==> См. подстановку параметров {var:pos:len} в Разделе 3.3.1
# ==> и примеры в этом разделе.
# ==> PASS=... -- добавление символа к строке PASS, полученной на предыдущих итерациях.

# ==> Чтобы детальнее проследить ход работы цикла, раскомментируйте следующую строку
# ==> echo "$PASS"
# ==> Вы увидите, как на каждом проходе цикла,
# ==> к строке PASS добавляется по одному символу.

let n+=1
# ==> Увеличить 'n' перед началом следующей итерации.

done

echo "$PASS" # ==> Или перенаправьте в файл, если пожелаете.
exit 0
</source> 
<big>+</big> 
''James R. Van Zandt'' предоставил следующий сценарий, который демонстрирует применение именованных каналов, по его словам, "на самом деле — упражнение на применение кавычек и на экранирование".
 '''Пример''': '''''A-17. fifo: Создание резервных копий с помощью именованных каналов.'''''
<source lang="bash">
#!/bin/bash
# ==> Автор:James R. Van Zandt
# ==> используется с его разрешения.

# ==> Комментарии, добавленные автором документа.

HERE=`uname -n` # ==> hostname
THERE=bilbo
echo "начало создания резервной копии на $THERE, за `date +%r`"
# ==> `date +%r` возвращает время в 12-ти часовом формате, т.е. "08:08:34 PM".

# убедиться в том, что /pipe — это действительно канал, а не простой файл
rm -rf /pipe
mkfifo /pipe # ==> Создание "именованного канала", с именем "/pipe".

# ==> 'su xyz' — запускает команду от имени пользователя "xyz".
# ==> 'ssh' — вызов secure shell (вход на удаленную систему).
su xyz -c "ssh $THERE \"cat >/home/xyz/backup/${HERE}-daily.tar.gz\" < /pipe"&
cd /
tar -czf - bin boot dev etc home info lib man root sbin share usr var >/pipe
# ==> Именованный канал /pipe, используется для передачи данных между процессами:
# ==> 'tar/gzip' пишет в /pipe, а 'ssh' -- читает из /pipe.

# ==> В результате будет получена резервная копия всех основных каталогов.

# ==> В чём состоит преимущество именованного канала, в данной ситуации,
# ==> перед неименованным каналом "|" ?
# ==> Будет ли работать неименованный канал в данной ситуации?

exit 0
</source> 
<big>+</big> 
''Stephane Chazelas'' предоставил следующий сценарий, который демонстрирует возможность генерации простых чисел без использования массивов.
 '''Пример''': '''''A-18. Генерация простых чисел, с использованием оператора деления по модулю(остаток от деления).'''''
<source lang="bash">
#!/bin/bash
# primes.sh: Генерация простых чисел, без использования массивов.
# Автор: Stephane Chazelas.

# Этот сценарий не использует классический алгоритм "Решето Эратосфена",
# вместо него используется более понятный метод проверки каждого кандидата в простые числа
# путём поиска делителей, с помощью оператора нахождения остатка от деления "%".

LIMIT=1000 # Простые от 2 до 1000

Primes()
{
(( n = $1 + 1 )) # Перейти к следующему числу.
shift # Следующий параметр в списке.
# echo "_n=$n i=$i_"
if (( n == LIMIT ))
then
echo $*
return
fi

for i; do # "i" устанавливается в "@", предыдущее значение $n.
# echo "-n=$n i=$i-"
(( i * i > n )) && break # Оптимизация.
(( n % i )) && continue # Отсечь составное число с помощью оператора "%".
Primes $n $@ # Рекурсивный вызов внутри цикла.
return
done

Primes $n $@ $n # Рекурсивный вызов за пределами цикла.
# Последовательное накопление позиционных параметров.
# в "$@" накапливаются простые числа.
}

Primes 1

exit 0

# Раскомментируйте строки 16 и 24, это поможет понять суть происходящего.

# Сравните скоростные характеристики этого сценария и сценария (ex68.sh),
# реализующего алгоритм "Решето Эратосфена".

# Упражнение: Попробуйте реализовать этот сценарий без использования рекурсии.
# Это даст некоторый выигрыш в скорости.
</source> 
<big>+</big> 
''Jordi Sanfeliu'' дал согласие на публикацию своего сценария '''tree'''.
 '''Пример''': '''''A-19. tree: Вывод дерева каталогов.'''''
<source lang="bash">
#!/bin/bash
# @(#) tree 1.1 30/11/95 by Jordi Sanfeliu
# email: mikaku@fiwix.org
#
# Начальная версия: 1.0 30/11/95
# Следующая версия: 1.1 24/02/97 Now, with symbolic links
# Исправления : Ian Kjos, поддержка недоступных каталогов
# email: beth13@mail.utexas.edu
#
# Tree — средство просмотра дерева каталогов (очевидно :-) )
#

# ==> Используется в данном документе с разрешения автора сценария, Jordi Sanfeliu.
# ==> Комментарии, добавленные автором документа.
# ==> Добавлено "окавычивание" аргументов.

search ()
{
for dir in `echo *`
# ==> `echo *` список всех файлов в текущем каталоге, без символов перевода строки.
# ==> Тот же эффект дает for dir in *
# ==> но "dir in `echo *`" не обрабатывает файлы, чьи имена содержат пробелы.
do
if [ -d "$dir" ] ; then # ==> Если это каталог (-d)...
zz=0 # ==> Временная переменная, для сохранения уровня вложенности каталога.
while [ $zz != $deep ] # Keep track of inner nested loop.
do
echo -n "| " # ==> Показать символ вертикальной связи,
# ==> с 2 пробелами и без перевода строки.
zz=`expr $zz + 1` # ==> Нарастить zz.
done
if [ -L "$dir" ] ; then # ==> Если символическая ссылка на каталог...
echo "+---$dir" `ls -l $dir | sed 's/^.*'$dir' //'`
# ==> Показать горизонтальный соединитель и имя связянного каталога, но...
# ==> без указания даты/времени.
else
echo "+---$dir" # ==> Вывести горизонтальный соединитель...
# ==> и название каталога.
if cd "$dir" ; then # ==> Если можно войти в каталог...
deep=`expr $deep + 1` # ==> Нарастить уровень вложенности.
search # рекурсия ;-)
numdirs=`expr $numdirs + 1` # ==> Нарастить счетчик каталогов.
fi
fi
fi
done
cd .. # ==> Подняться на один уровень вверх.
if [ "$deep" ] ; then # ==> Если depth = 0 (возвращает TRUE)...
swfi=1 # ==> выставить признак окончания поиска.
fi
deep=`expr $deep - 1` # ==> Уменьшить уровень вложенности.
}

# - Main -
if [ $# = 0 ] ; then
cd `pwd` # ==> Если аргумент командной строки отсутствует, то используется текущий каталог.
else
cd $1 # ==> иначе перейти в заданный каталог.
fi
echo "Начальный каталог = `pwd`"
swfi=0 # ==> Признак завершения поиска.
deep=0 # ==> Уровень вложенности.
numdirs=0
zz=0

while [ "$swfi" != 1 ] # Пока поиск не закончен...
do
search # ==> Вызвать функцию поиска.
done
echo "Всего каталогов = $numdirs"

exit 0
# ==> Попробуйте разобраться в том как этот сценарий работает.
</source> 
''Noah Friedman'' дал разрешение на публикацию своей библиотеки функций для работы со строками, которая, по сути, воспроизводит некоторые библиотечные функции языка ''C''.
 '''Пример''': '''''A-20. Функции для работы со строками.'''''
<source lang="bash">
#!/bin/bash
# string.bash --- эмуляция библиотеки функций string(3)
# Автор: Noah Friedman <friedman@prep.ai.mit.edu>
# ==> Используется с его разрешения.
# Дата создания: 1992-07-01
# Дата последней модификации: 1993-09-29
# Public domain
# Преобразование в синтаксис bash v2 выполнил Chet Ramey
# Комментарий:
# Код:

#:docstring strcat:
# Порядок использования: strcat s1 s2
#
# Strcat добавляет содержимое переменной s2 к переменной s1.
#
# Пример:
# a="foo"
# b="bar"
# strcat a b
# echo $a
# => foobar
#
#:end docstring:

###;;;autoload
function strcat ()
{
local s1_val s2_val
s1_val=${!1} # косвенная ссылка
s2_val=${!2}
eval "$1"=\'"${s1_val}${s2_val}"\'
# ==> eval $1='${s1_val}${s2_val}' во избежание проблем,
# ==> если одна из переменных содержит одиночную кавычку.
}
#:docstring strncat:
# Порядок использования: strncat s1 s2 $n
#
# Аналог strcat, но добавляет не более n символов из
# переменной s2. Результат выводится на stdout.
#
# Пример:
# a=foo
# b=barbaz
# strncat a b 3
# echo $a
# => foobar
#
#:end docstring:

###;;;autoload
function strncat ()
{
local s1="$1"
local s2="$2"
local -i n="$3"
local s1_val s2_val

s1_val=${!s1} # ==> косвенная ссылка
s2_val=${!s2}

if [ ${#s2_val} -gt ${n} ]; then
s2_val=${s2_val:0:$n} # ==> выделение подстроки
fi

eval "$s1"=\'"${s1_val}${s2_val}"\'
# ==> eval $1='${s1_val}${s2_val}' во избежание проблем,
# ==> если одна из переменных содержит одиночную кавычку.
}

#:docstring strcmp:
# Порядок использования: strcmp $s1 $s2
#
# Strcmp сравнивает две строки и возвращает число меньше, равно
# или больше нуля, в зависимости от результатов сравнения.
#:end docstring:

###;;;autoload
function strcmp ()
{
[ "$1" = "$2" ] && return 0
[ "${1}" '<' "${2}" ] > /dev/null && return -1
return 1
}

#:docstring strncmp:
# Порядок использования: strncmp $s1 $s2 $n
#
# Подобна strcmp, но сравнивает не более n символов
#:end docstring:

###;;;autoload
function strncmp ()
{
if [ -z "${3}" -o "${3}" -le "0" ]; then
return 0
fi

if [ ${3} -ge ${#1} -a ${3} -ge ${#2} ]; then
strcmp "$1" "$2"
return $?
else
s1=${1:0:$3}
s2=${2:0:$3}
strcmp $s1 $s2
return $?
fi
}

#:docstring strlen:
# Порядок использования: strlen s
#
# возвращает количество символов в строке s.
#:end docstring:

###;;;autoload
function strlen ()
{
eval echo "\${#${1}}"
# ==> Возвращает длину переменной,
# ==> чье имя передаётся как аргумент.
}

#:docstring strspn:
# Порядок использования: strspn $s1 $s2
#
# Strspn возвращает максимальную длину сегмента в строке s1,
# который полностью состоит из символов строки s2.
#:end docstring:

###;;;autoload
function strspn ()
{
# Сброс содержимого переменной IFS позволяет обрабатывать пробелы как обычные символы.
local IFS=
local result="${1%%[!${2}]*}"

echo ${#result}
}

#:docstring strcspn:
# Порядок использования: strcspn $s1 $s2
#
# Strcspn возвращает максимальную длину сегмента в строке s1,
# который полностью не содержит символы из строки s2.
#:end docstring:

###;;;autoload
function strcspn ()
{
# Сброс содержимого переменной IFS позволяет обрабатывать пробелы как обычные символы.
local IFS=
local result="${1%%[${2}]*}"

echo ${#result}
}

#:docstring strstr:
# Порядок использования: strstr s1 s2
#
# Strstr выводит подстроку первого вхождения строки s2
# в строке s1, или ничего не выводит, если подстрока s2 в строке s1 не найдена.
# Если s2 содержит строку нулевой длины, то strstr выводит строку s1.
#:end docstring:

###;;;autoload
function strstr ()
{
# Если s2 — строка нулевой длины, то вывести строку s1
[ ${#2} -eq 0 ] && { echo "$1" ; return 0; }
# не выводить ничего, если s2 не найдена в s1
case "$1" in
*$2*) ;;
*) return 1;;
esac

# использовать шаблон, для удаления всех несоответствий после s2 в s1
first=${1/$2*/}

# Затем удалить все несоответствия с начала строки
echo "${1##$first}"
}

#:docstring strtok:
# Порядок использования: strtok s1 s2
#
# Strtok рассматривает строку s1, как последовательность из 0, или более,
# лексем (токенов), разделённых символами строки s2
# При первом вызове (с непустым аргументом s1)
# выводит первую лексему на stdout.
# Функция запоминает свое положение в строке s1 от вызова к вызову,
# так что последующие вызовы должны производиться с пустым первым аргументом,
# чтобы продолжить выделение лексем из строки s1.
# После вывода последней лексемы, все последующие вызовы будут выводить на stdout
# пустое значение. Строка-разделитель может изменяться от вызова к вызову.
#:end docstring:

###;;;autoloa
dfunction strtok ()
{
:
}

#:docstring strtrunc:
# Порядок использования: strtrunc $n $s1 {$s2} {$...}
#
# Используется многими функциями, такими как strncmp, чтобы отсечь "лишние" символы.
# Выводит первые n символов в каждой из строк s1 s2 ... на stdout.
#:end docstring:

###;;;autoload
function strtrunc ()
{
n=$1 ; shift
for z; do
echo "${z:0:$n}"
done
}

# provide string
# string.bash конец библиотеки

# ========================================================================== #
# ==> Все, что находится ниже, добавлено автором документа.
# ==> Чтобы этот сценарий можно было использовать как "библиотеку", необходимо
# ==> удалить все, что находится ниже и "source" этот файл в вашем сценарии.

# strcat
string0=one
string1=two
echo
echo "Проверка функции \"strcat\" :"
echo "Изначально \"string0\" = $string0"
echo "\"string1\" = $string1"
strcat string0 string1
echo "Теперь \"string0\" = $string0"
echo

# strlen
echo
echo "Проверка функции \"strlen\" :"
str=123456789
echo "\"str\" = $str"
echo -n "Длина строки \"str\" = "
strlen str
echo

# Упражнение:
# ---------
# Добавьте проверку остальных функций.

exit 0
</source> 
''Michael Zick'' предоставил очень сложный пример работы с массивами и утилитой '''''md5sum''''', используемой для кодирования сведений о каталоге.
''От переводчика'': 
'''''К своему стыду вынужден признаться, что перевод комментариев оказался мне не "по зубам",поэтому оставляю этот сценарий без перевода'''''.
 '''Пример''': '''''A-21. Directory information.'''''
<source lang="bash">
#!/bin/bash
# directory-info.sh
# Parses and lists directory information.

# NOTE: Change lines 273 and 353 per "README" file.

# Michael Zick is the author of this script.
# Used here with his permission.

# Controls
# If overridden by command arguments, they must be in the order:
# Arg1: "Descriptor Directory"
# Arg2: "Exclude Paths"
# Arg3: "Exclude Directories"
#
# Environment Settings override Defaults.
# Command arguments override Environment Settings.

# Default location for content addressed file descriptors.
MD5UCFS=${1:-${MD5UCFS:-'/tmpfs/ucfs'}}

# Directory paths never to list or enter
declare -a \
EXCLUDE_PATHS=${2:-${EXCLUDE_PATHS:-'(/proc /dev /devfs /tmpfs)'}}

# Directories never to list or enter
declare -a \
EXCLUDE_DIRS=${3:-${EXCLUDE_DIRS:-'(ucfs lost+found tmp wtmp)'}}

# Files never to list or enter
declare -a \
EXCLUDE_FILES=${3:-${EXCLUDE_FILES:-'(core "Name with Spaces")'}}

# Here document used as a comment block.
: << LSfieldsDoc
# # # # # List Filesystem Directory Information # # # # #
#
# ListDirectory "FileGlob" "Field-Array-Name"
# or
# ListDirectory -of "FileGlob" "Field-Array-Filename"
# '-of' meaning 'output to filename'
# # # # #

String format description based on: ls (GNU fileutils) version 4.0.36

Produces a line (or more) formatted:
inode permissions hard-links owner group ...
32736 -rw------- 1 mszick mszick
size day month date hh:mm:ss year path
2756608 Sun Apr 20 08:53:06 2003 /home/mszick/core

Unless it is formatted:
inode permissions hard-links owner group ...
266705 crw-rw---- 1 root uucp
major minor day month date hh:mm:ss year path
4, 68 Sun Apr 20 09:27:33 2003 /dev/ttyS4
NOTE: that pesky comma after the major number
NOTE: the 'path' may be multiple fields:
/home/mszick/core
/proc/982/fd/0 -> /dev/null
/proc/982/fd/1 -> /home/mszick/.xsession-errors
/proc/982/fd/13 -> /tmp/tmpfZVVOCs (deleted)
/proc/982/fd/7 -> /tmp/kde-mszick/ksycoca
/proc/982/fd/8 -> socket:[11586]
/proc/982/fd/9 -> pipe:[11588]

If that isn't enough to keep your parser guessing,
either or both of the path components may be relative:
../Built-Shared -> Built-Static
../linux-2.4.20.tar.bz2 -> ../../../SRCS/linux-2.4.20.tar.bz2

The first character of the 11 (10?) character permissions field:
's' Socket
'd' Directory
'b' Block device
'c' Character device
'l' Symbolic link
NOTE: Hard links not marked - test for identical inode numbers on identical filesystems.
All information about hard linked files are shared, except
for the names and the name's location in the directory system.
NOTE: A "Hard link" is known as a "File Alias" on some systems.
'-' An undistingushed fileFollowed by three groups of letters for: User, Group, Others
Character 1: '-' Not readable; 'r' Readable
Character 2: '-' Not writable; 'w' Writable
Character 3, User and Group: Combined execute and special
'-' Not Executable, Not Special
'x' Executable, Not Special
's' Executable, Special
'S' Not Executable, Special
Character 3, Others: Combined execute and sticky (tacky?)
'-' Not Executable, Not Tacky
'x' Executable, Not Tacky
't' Executable, Tacky
'T' Not Executable, Tacky
Followed by an access indicator
Haven't tested this one, it may be the eleventh character
or it may generate another field
' ' No alternate access
'+' Alternate access
LSfieldsDoc

ListDirectory()
{
local -a T
local -i of=0 # Default return in variable
# OLD_IFS=$IFS # Using BASH default ' \t\n'
case "$#" in
3) case "$1" in
-of) of=1 ; shift ;;
* ) return 1 ;;
esac ;;
2) : ;; # Poor man's "continue"
*) return 1 ;;
esac
# NOTE: the (ls) command is NOT quoted (")
T=( $(ls --inode --ignore-backups --almost-all --directory \
--full-time --color=none --time=status --sort=none \
--format=long $1) )

case $of in
# Assign T back to the array whose name was passed as $2
0) eval $2=$ \"\$\{T\[@\]\}\" $ ;;
# Write T into filename passed as $2
1) echo "${T[@]}" > "$2" ;;
esac
return 0
}
# # # # # Is that string a legal number? # # # # #
#
# IsNumber "Var"
# # # # # There has to be a better way, sigh...

IsNumber()
{
local -i int
if [ $# -eq 0 ]
then
return 1
else
(let int=$1) 2>/dev/null
return $? # Exit status of the let thread
fi
}

# # # # # Index Filesystem Directory Information # # # # #
#
# IndexList "Field-Array-Name" "Index-Array-Name"
# or
# IndexList -if Field-Array-Filename Index-Array-Name
# IndexList -of Field-Array-Name Index-Array-Filename
# IndexList -if -of Field-Array-Filename Index-Array-Filename
#
# # # #
: << IndexListDoc
Walk an array of directory fields produced by ListDirectory
Having suppressed the line breaks in an otherwise line oriented
report, build an index to the array element which starts each line.

Each line gets two index entries, the first element of each line
(inode) and the element that holds the pathname of the file.

The first index entry pair (Line-Number==0) are informational:
Index-Array-Name[0] : Number of "Lines" indexed
Index-Array-Name[1] : "Current Line" pointer into Index-Array-Name
The following index pairs (if any) hold element indexes into
the Field-Array-Name per:
Index-Array-Name[Line-Number * 2] : The "inode" field element.
NOTE: This distance may be either +11 or +12 elements.
Index-Array-Name[(Line-Number * 2) + 1] : The "pathname" element.
NOTE: This distance may be a variable number of elements.
Next line index pair for Line-Number+1.
IndexListDoc

IndexList()
{
local -a LIST # Local of listname passed
local -a -i INDEX=( 0 0 ) # Local of index to return
local -i Lidx Lcnt
local -i if=0 of=0 # Default to variable names

case "$#" in # Simplistic option testing
0) return 1 ;;
1) return 1 ;;
2) : ;; # Poor man's continue
3) case "$1" in
-if) if=1 ;;
-of) of=1 ;;
* ) return 1 ;;
esac ; shift ;;
4) if=1 ; of=1 ; shift ; shift ;;
*) return 1
esac

# Make local copy of list
case "$if" in
0) eval LIST=$ \"\$\{$1\[@\]\}\" $ ;;
1) LIST=( $(cat $1) ) ;;
esac

# Grok (grope?) the array
Lcnt=${#LIST[@]}
Lidx=0
until (( Lidx >= Lcnt ))
do
if IsNumber ${LIST[$Lidx]}
then
local -i inode name
local ft
inode=Lidx
local m=${LIST[$Lidx+2]} # Hard Links field
ft=${LIST[$Lidx+1]:0:1} # Fast-Stat
case $ft in
b) ((Lidx+=12)) ;; # Block device
c) ((Lidx+=12)) ;; # Character device
*) ((Lidx+=11)) ;; # Anything else
esac
name=Lidx
case $ft in
-) ((Lidx+=1)) ;; # The easy one
b) ((Lidx+=1)) ;; # Block device
c) ((Lidx+=1)) ;; # Character device
d) ((Lidx+=1)) ;; # The other easy one
l) ((Lidx+=3)) ;; # At LEAST two more fields
# A little more elegance here would handle pipes,
# sockets, deleted files - later.
*) until IsNumber ${LIST[$Lidx]} || ((Lidx >= Lcnt))
do
((Lidx+=1))
done
;; # Not required
esac
INDEX[${#INDEX[*]}]=$inode
INDEX[${#INDEX[*]}]=$name
INDEX[0]=${INDEX[0]}+1 # One more "line" found
# echo "Line: ${INDEX[0]} Type: $ft Links: $m Inode: \
# ${LIST[$inode]} Name: ${LIST[$name]}"
else
((Lidx+=1))
fi
done
case "$of" in
0) eval $2=$ \"\$\{INDEX\[@\]\}\" $ ;;
1) echo "${INDEX[@]}" > "$2" ;;
esac
return 0 # What could go wrong?
}
# # # # # Content Identify File # # # # #
#
# DigestFile Input-Array-Name Digest-Array-Name
# or
# DigestFile -if Input-FileName Digest-Array-Name
# # # # #

# Here document used as a comment block.
: <<DigestFilesDoc

The key (no pun intended) to a Unified Content File System (UCFS)
is to distinguish the files in the system based on their content.
Distinguishing files by their name is just, so, 20th Century.

The content is distinguished by computing a checksum of that content.
This version uses the md5sum program to generate a 128 bit checksum
representative of the file's contents.
There is a chance that two files having different content might
generate the same checksum using md5sum (or any checksum). Should
that become a problem, then the use of md5sum can be replace by a
cyrptographic signature. But until then...

The md5sum program is documented as outputting three fields (and it
does), but when read it appears as two fields (array elements). This
is caused by the lack of whitespace between the second and third field.
So this function gropes the md5sum output and returns:
[0] 32 character checksum in hexidecimal (UCFS filename)
[1] Single character: ' ' text file, '*' binary file
[2] Filesystem (20th Century Style) name
Note: That name may be the character '-' indicating STDIN read.
DigestFilesDoc

DigestFile()
{
local if=0 # Default, variable name
local -a T1 T2
case "$#" in
3) case "$1" in
-if) if=1 ; shift ;;
* ) return 1 ;;
esac ;;
2) : ;; # Poor man's "continue"
*) return 1 ;;
esac

case $if in
0) eval T1=$ \"\$\{$1\[@\]\}\" $
T2=( $(echo ${T1[@]} | md5sum -) )
;;
1) T2=( $(md5sum $1) )
;;
esac

case ${#T2[@]} in
0) return 1 ;;
1) return 1 ;;
2) case ${T2[1]:0:1} in # SanScrit-2.0.5
\*) T2[${#T2[@]}]=${T2[1]:1}
T2[1]=\*
;;
*) T2[${#T2[@]}]=${T2[1]}
T2[1]=" "
;;
esac
;;
3) : ;; # Assume it worked
*) return 1 ;;
esac

local -i len=${#T2[0]}
if [ $len -ne 32 ] ; then return 1 ; fi
eval $2=$ \"\$\{T2\[@\]\}\" $
}

# # # # # Locate File # # # # #
#
#
# LocateFile [-l] FileName Location-Array-Name
# or
# LocateFile [-l] -of FileName Location-Array-FileName
# # # # #

# A file location is Filesystem-id and inode-number
# Here document used as a comment block.
: <<StatFieldsDoc
Based on stat, version 2.2
stat -t and stat -lt fields
[0] name
[1] Total size
File - number of bytes
Symbolic link - string length of pathname
[2] Number of (512 byte) blocks allocated
[3] File type and Access rights (hex)
[4] User ID of owner
[5] Group ID of owner
[6] Device number
[7] Inode number
[8] Number of hard links
[9] Device type (if inode device) Major
[10] Device type (if inode device) Minor
[11] Time of last access
May be disabled in 'mount' with noatime
atime of files changed by exec, read, pipe, utime, mknod (mmap?)
atime of directories changed by addition/deletion of files
[12] Time of last modification
mtime of files changed by write, truncate, utime, mknod
mtime of directories changed by addtition/deletion of files
[13] Time of last change
ctime reflects time of changed inode information (owner, group
permissions, link count
-*-*- Per:
Return code: 0
Size of array: 14
Contents of array
Element 0: /home/mszick
Element 1: 4096
Element 2: 8
Element 3: 41e8
Element 4: 500
Element 5: 500
Element 6: 303
Element 7: 32385
Element 8: 22
Element 9: 0
Element 10: 0
Element 11: 1051221030
Element 12: 1051214068
Element 13: 1051214068

For a link in the form of linkname -> realname
stat -t linkname returns the linkname (link) information
stat -lt linkname returns the realname information

stat -tf and stat -ltf fields
[0] name
[1] ID-0? # Maybe someday, but Linux stat structure
[2] ID-0? # does not have either LABEL nor UUID
# fields, currently information must come
# from file-system specific utilities
These will be munged into:
[1] UUID if possible
[2] Volume Label if possible
Note: 'mount -l' does return the label and could return the UUID

[3] Maximum length of filenames
[4] Filesystem type
[5] Total blocks in the filesystem
[6] Free blocks
[7] Free blocks for non-root user(s)
[8] Block size of the filesystem
[9] Total inodes
[10] Free inodes
-*-*- Per:
Return code: 0
Size of array: 11
Contents of array
Element 0: /home/mszick
Element 1: 0
Element 2: 0
Element 3: 255
Element 4: ef53
Element 5: 2581445
Element 6: 2277180
Element 7: 2146050
Element 8: 4096
Element 9: 1311552
Element 10: 1276425

StatFieldsDoc

# LocateFile [-l] FileName Location-Array-Name
# LocateFile [-l] -of FileName Location-Array-FileName

LocateFile()
{
local -a LOC LOC1 LOC2
local lk="" of=0

case "$#" in
0) return 1 ;;
1) return 1 ;;
2) : ;;
*) while (( "$#" > 2 ))
do
case "$1" in
-l) lk=-1 ;;
-of) of=1 ;;
*) return 1 ;;
esac
shift
done ;;
esac

# More Sanscrit-2.0.5
# LOC1=( $(stat -t $lk $1) )
# LOC2=( $(stat -tf $lk $1) )
# Uncomment above two lines if system has "stat" command installed.

LOC=( ${LOC1[@]:0:1} ${LOC1[@]:3:11}
${LOC2[@]:1:2} ${LOC2[@]:4:1} )

case "$of" in
0) eval $2=$ \"\$\{LOC\[@\]\}\" $ ;;
1) echo "${LOC[@]}" > "$2" ;;
esac
return 0

# Which yields (if you are lucky, and have "stat" installed)
# -*-*- Location Discriptor -*-*-
# Return code: 0
# Size of array: 15
# Contents of array
# Element 0: /home/mszick 20th Century name
# Element 1: 41e8 Type and Permissions
# Element 2: 500 User
# Element 3: 500 Group
# Element 4: 303 Device
# Element 5: 32385 inode
# Element 6: 22 Link count
# Element 7: 0 Device Major
# Element 8: 0 Device Minor
# Element 9: 1051224608 Last Access
# Element 10: 1051214068 Last Modify
# Element 11: 1051214068 Last Status
# Element 12: 0 UUID (to be)
# Element 13: 0 Volume Label (to be)
# Element 14: ef53 Filesystem type
}

# And then there was some test
codeListArray() # ListArray Name
{
local -a Ta

eval Ta=$ \"\$\{$1\[@\]\}\" $
echo
echo "-*-*- List of Array -*-*-"
echo "Size of array $1: ${#Ta[*]}"
echo "Contents of array $1:"
for (( i=0 ; i<${#Ta[*]} ; i++ ))
do
echo -e "\tElement $i: ${Ta[$i]}"
done
return 0
}

declare -a CUR_DIR
# For small arrays
ListDirectory "${PWD}" CUR_DIR
ListArray CUR_DIR

declare -a DIR_DIG
DigestFile CUR_DIR DIR_DIG
echo "The new \"name\" (checksum) for ${CUR_DIR[9]} is ${DIR_DIG[0]}"

declare -a DIR_ENT
# BIG_DIR # For really big arrays - use a temporary file in ramdisk
# BIG-DIR # ListDirectory -of "${CUR_DIR[11]}/*" "/tmpfs/junk2"

ListDirectory "${CUR_DIR[11]}/*" DIR_ENT

declare -a DIR_IDX# BIG-DIR # IndexList -if "/tmpfs/junk2" DIR_IDX
IndexList DIR_ENT DIR_IDX
declare -a IDX_DIG# BIG-DIR # DIR_ENT=( $(cat /tmpfs/junk2) )
# BIG-DIR # DigestFile -if /tmpfs/junk2 IDX_DIG
DigestFile DIR_ENT IDX_DIG
# Small (should) be able to parallize IndexList & DigestFile
# Large (should) be able to parallize IndexList & DigestFile & the assignment
echo "The \"name\" (checksum) for the contents of ${PWD} is ${IDX_DIG[0]}"

declare -a FILE_LOC
LocateFile ${PWD} FILE_LOC
ListArray FILELOC

exit 0
</source> 
''Stephane Chazelas'' демонстрирует возможность объектно-ориентированного подхода к программированию в Bash-сценариях.
 '''Пример''': '''''A-22. Объектно-ориентированная база данных.'''''
<source lang="bash">
#!/bin/bash
# obj-oriented.sh: Объектно-ориентрованный подход к программированию в сценариях.
# Автор: Stephane Chazelas.

person.new() # Очень похоже на объявление класса в C++.
{
local obj_name=$1 name=$2 firstname=$3 birthdate=$4

eval "$obj_name.set_name() {
eval \"$obj_name.get_name() {
echo \$1
}\"
}"
eval "$obj_name.set_firstname() {
eval \"$obj_name.get_firstname() {
echo \$1
}\"
}"
eval "$obj_name.set_birthdate() {
eval \"$obj_name.get_birthdate() {
echo \$1
}\"
eval \"$obj_name.show_birthdate() {
echo \$(date -d \"1/1/1970 0:0:\$1 GMT\")
}\"
eval \"$obj_name.get_age() {
echo \$(( (\$(date +%s) - \$1) / 3600 / 24 / 365 ))
}\"
}"

$obj_name.set_name $name
$obj_name.set_firstname $firstname
$obj_name.set_birthdate $birthdate
}

echo
person.new self Bozeman Bozo 101272413
# Создаётся экземпляр класса "person.new" (фактически — вызов функции с аргументами).
self.get_firstname # Bozo
self.get_name # Bozeman
self.get_age # 28
self.get_birthdate # 101272413
self.show_birthdate # Sat Mar 17 20:13:33 MST 1973

echo

# typeset -f # чтобы просмотреть перечень созданных функций.
exit 0
</source> 
'''Пример сценария, имеющего практическую ценность: установка и монтирование USB-устройств"жёстких дисков".'''
 '''Пример''': '''''A-23. Монтирование USB-устройств флэш-памяти.'''''
<source lang="bash">
#!/bin/bash
# ==> usb.sh
# ==> Сценарий монтирует и устанавливает USB-устройства флэш-памяти.
# ==> Запускается с правами root во время загрузки системы (см. ниже).

# Этот сценарий распространяется на условиях GNU GPL license версии 2 или выше.
# Полный текст лицензии вы найдете на http://www.gnu.org/.
#
# Часть кода заимствована из сценария usb-mount, автор Michael Hamilton (LGPL)
# см. http://users.actrix.co.nz/michael/usbmount.html#
#
# УСТАНОВКА
# ---------
# Поместите сценарий в каталог /etc/hotplug/usb/diskonkey.
# Затем скопируйте все описания устройств usb-storage из /etc/hotplug/usb.distmap
# в /etc/hotplug/usb.usermap, заменяя "usb-storage" на "diskonkey".
#
# TODO
# ----
# Обслуживание более одного устройства diskonkey (например /dev/diskonkey1
# и /mnt/diskonkey1), и т.д. Наибольшая проблема здесь состоит в работе с
# devlabel.
#
# АВТОР и ПОДДЕРЖКА
# -------------------
# Konstantin Riabitsev, <icon linux duke edu>.
# Сообщения об обнаруженных ошибках отправляйте мне на электронный адрес.
#
# ==> Комментарии добавленные автором книги.

SYMLINKDEV=/dev/diskonkey
MOUNTPOINT=/mnt/diskonkey
DEVLABEL=/sbin/devlabel
DEVLABELCONFIG=/etc/sysconfig/devlabel
IAM=$0

##
# Функция заимствована из usb-mount.
#

function allAttachedScsiUsb {
find /proc/scsi/ -path '/proc/scsi/usb-storage*' -type f | xargs grep -l 'Attached: Yes'
}

function scsiDevFromScsiUsb {
echo $1 | awk -F"[-/]" '{ n=$(NF-1); print "/dev/sd" substr("abcdefghijklmnopqrstuvwxyz", n+1, 1) }'
}

if [ "${ACTION}" = "add" ] && [ -f "${DEVICE}" ]; then
##
# заимствовано из usbcam.
#
if [ -f /var/run/console.lock ]; then
CONSOLEOWNER=`cat /var/run/console.lock`
elif [ -f /var/lock/console.lock ]; then
CONSOLEOWNER=`cat /var/lock/console.lock`
else
CONSOLEOWNER=
fi

for procEntry in $(allAttachedScsiUsb); do
scsiDev=$(scsiDevFromScsiUsb $procEntry)
# Это ошибка в usb-storage?
# Разделы не появляются в /proc/partitions до тех пор
# пока к ним не было хотя бы одного обращения.
/sbin/fdisk -l $scsiDev >/dev/null
##
# Большинство устройств имеет информацию о разделах, например
# /dev/sd?1. Однако, некоторые устройства не имеют разделов
# выделяя под данные весь объем памяти. Здесь делается
# попытка определить такие устройства, т.е. имеется ли /dev/sd?1
# или нет.
#
if grep -q `basename $scsiDev`1 /proc/partitions; then
part="$scsiDev""1"
else
part=$scsiDev
fi
##
# Изменение владельца устройства, чтобы пользователь
# мог смонтировать его.
#
if [ ! -z "$CONSOLEOWNER" ]; then
chown $CONSOLEOWNER:disk $part
fi
##
# Здесь проверяется — зарегистрирован ли UUID с помощью devlabel.
# Если нет, то устройство добавляется в список.
#
prodid=`$DEVLABEL printid -d $part`
if ! grep -q $prodid $DEVLABELCONFIG; then
# скрестим пальцы, надеюсь это поможет
$DEVLABEL add -d $part -s $SYMLINKDEV 2>/dev/null
fi
##
# Если точка монтирования отсутствует, то она создается.
#
if [ ! -e $MOUNTPOINT ]; then
mkdir -p $MOUNTPOINT
fi
##
# Позаботиться о создании соответствующей записи в /etc/fstab.
#
if ! grep -q "^$SYMLINKDEV" /etc/fstab; then
# Добавить запись в fstab
echo -e \
"$SYMLINKDEV\t\t$MOUNTPOINT\t\tauto\tnoauto,owner,kudzu 0 0" \
>> /etc/fstab
fi
done

if [ ! -z "$REMOVER" ]; then
##
# Обеспечить запуск сценария при извлечении устройства.
#
mkdir -p `dirname $REMOVER`
ln -s $IAM $REMOVER
fi

elif [ "${ACTION}" = "remove" ]; then
##
# Если устройство смонтировано — отмонтировать его.
#
if grep -q "$MOUNTPOINT" /etc/mtab; then
# отмонтировать
umount -l $MOUNTPOINT
fi
##
# Удалить запись из /etc/fstab, если она там имеется.
#
if grep -q "^$SYMLINKDEV" /etc/fstab; then
grep -v "^$SYMLINKDEV" /etc/fstab > /etc/.fstab.new
mv -f /etc/.fstab.new /etc/fstab
fi
fi
</source> 

'''А этот сценарий согреет душу и сердце и веб-мастера, и владельца сайта: он создаёт резервную копию файлов журналов WEB-сервера'''.
 '''Пример''': '''''A-24. Резервное копирование файлов журналов.'''''
<source lang="bash">
#!/bin/bash
# archiveweblogs.sh v1.0

# Troy Engel <tengel@fluid.com>
# С небольшими изменениями, внесёнными автором документа.
# Используется с разрешения автора.
#
# Этот сценарий выполняет резервное копирование
# файлов журналов из стандартного каталога установки RedHat/Apache.
# Вставляет дату создания копии в имя файла-архива,
# сжимает (bzip), и помещает сжатые файлы в заданный каталог.
#
# Запускается из crontab ночью в 00 часов,
# так как bzip2 потребляет значительную часть ресурсов процессора,
# если журналы достаточно велики:
# 0 2 * * * /opt/sbin/archiveweblogs.sh

PROBLEM=66
# Здесь укажите ваш каталог для архивации.
BKP_DIR=/opt/backups/weblogs

# Настройки Apache/RedHat по-умолчанию
LOG_DAYS="4 3 2 1"
LOG_DIR=/var/log/httpd
LOG_FILES="access_log error_log"

# Расположение программ в RedHat по-умолчанию
LS=/bin/ls
MV=/bin/mv
ID=/usr/bin/id
CUT=/bin/cut
COL=/usr/bin/column
BZ2=/usr/bin/bzip2

# Проверка прав пользователя?
USER=`$ID -u`
if [ "X$USER" != "X0" ]; then
echo "PANIC: Только root может запускать этот сценарий!"
exit $PROBLEM
fi

# Каталог для резервной копии существует и доступен на запись?
if [ ! -x $BKP_DIR ]; then
echo "PANIC: Каталог $BKP_DIR не найден или не доступен для записи!"
exit $PROBLEM
fi

# Переместить, переименовать и сжать
for logday in $LOG_DAYS; do
for logfile in $LOG_FILES; do
MYFILE="$LOG_DIR/$logfile.$logday"
if [ -w $MYFILE ]; then
DTS=`$LS -lgo --time-style=+%Y%m%d $MYFILE | $COL -t | $CUT -d ' ' -f7`
$MV $MYFILE $BKP_DIR/$logfile.$DTS
$BZ2 $BKP_DIR/$logfile.$DTS
else
# Выдать сообщение об ошибке, если файл недоступен на запись.
if [ -f $MYFILE ]; then
echo "ERROR: $MYFILE not writable. Skipping."
fi
fi
done
done
exit 0
</source> 
'''Как предотвратить интерпретацию строки в сценарии'''?
 '''Пример''': '''''A-25. Предотвращение интерпретации строк символов.'''''
<source lang="bash">
#! /bin/bash
# protect_literal.sh
# set -vx
:<<-'_Protect_Literal_String_Doc'
Copyright (c) Michael S. Zick, 2003; All Rights Reserved
Ограничения: Допускается использовать без каких либо ограничений в любой форме.
Гарантии: Никаких
Издание: $ID$

Этот встроенный документ Bash отправит на устройство '/dev/null'.
(Раскомментарьте команду set, стоящую выше, чтобы убедиться в этом.)

Удалите первую строку (Sha-Bang), если вы собираетесь использовать этот сценарий
в качестве библиотеки. Не забудьте при этом закомментарить примеры
использования процедур (там где это указано).

Порядок использования:
_protect_literal_str 'Whatever string meets your ${fancy}'
Какая бы строка ни была передана функции,
она просто будет выведена на stdout,
включая "строгие" кавычки.

$(_protect_literal_str 'Whatever string meets your ${fancy}')
как правосторонняя часть операции присваивания.

Назначение:
В операциях присваивания, предотвращают дополнительную
интерпретацию содержимого строки, путем добавления "строгих" кавычек.

Примечание:
Имена функций (_*) выбраны таким образом, чтобы избежать
конфликтов имён, при подключении данного сценария
к пользовательским сценариям, в качестве библиотеки.

_Protect_Literal_String_Doc

_protect_literal_str() {
# Выберем неиспользуемый, непечатный символ в качестве разделителя полей для IFS.
# В этом нет необходимости, но делается это для демонстрации
# того, что разделитель полей игнорируется.
local IFS=$'\x1B' # Символ \ESC
# Заключим Все-Элементы в "строгие" кавычки.
local tmp=$'\x27'$@$'\x27'

local len=${#tmp} # Исключительно для демонстрации.
echo $tmp, длина:$len. # Вывод строки и дополнительной информации.
}

# Версия с более коротким именем.
_pls() {
local IFS=$'x1B' # Символ \ESC (не обязательно)
echo $'\x27'$@$'\x27' # Заключить в "строгие" кавычки
}

# :<<-'_Protect_Literal_String_Test'
# # # Раскомментарьте вышестоящую строку, чтобы запретить исполнение нижеследующего кода. # # #

# Посмотрим как выглядит простой вывод.
echo
echo "- - Тест #1 - -"

_protect_literal_str 'Hello $user'
_protect_literal_str 'Hello "${username}"'
echo

# В результате должно получиться:
# - - Тест #1 - -
# 'Hello $user', длина: 13.
# 'Hello "${username}"', длина: 21.

# Собственно получили то, что и ожидали, тогда в чем проблема?
# Проблема скрыта внутри Bash, в порядке выполнения операций.
# Она проявляется, когда функции участвуют в операциях присваивания.

# Объявим массив тестовых значений.
declare -a arrayZ

# Запишем в массив элементы с разного рода кавычками и экранирующими символами.
arrayZ=( zero "$(_pls 'Hello ${Me}')" 'Hello ${You}' "\'Pass: ${pw}\'" )

# Теперь выведем массив на экран и посмотрим, что там лежит.
echo "- - Тест #2 - -"
for (( i=0 ; i<${#arrayZ[*]} ; i++ ))
do
echo Элемент $i: ${arrayZ[$i]}, длина: ${#arrayZ[$i]}.
done
echo

# В результате должно получиться:
# - - Тест #2 - -
# Элемент 0: zero, длина: 4.
# Маркировочный (ничем не примечательный) элемент
# Элемент 1: 'Hello ${Me}', длина: 13. # Результат "$(_pls '...' )"
# Элемент 2: Hello ${You}, длина: 12. # Кавычки исчезли
# Элемент 3: \'Pass: \', длина: 10. # ${pw} -- была интерпретирована,
# # а на её место подставлена пустая строка

# Выполним присвоение одного массива другому.
declare -a array2=( ${arrayZ[@]} )

# И выведем его содержимое.
echo "- - Тест #3 - -"
for (( i=0 ; i<${#array2[*]} ; i++ ))
do
echo Элемент $i: ${array2[$i]}, длина: ${#array2[$i]}.
done
echo

# В результате должно получиться:
# - - Тест #3 - -
# Элемент 0: zero, длина: 4. # Наш маркер.
# Элемент 1: Hello ${Me}, длина: 11. # Вполне предсказуемый результат.
# Элемент 2: Hello, длина: 5. # ${You} -- была интерпретирована.
# # а на её место подставлена пустая строка
# Элемент 3: 'Pass:, длина: 6. # Элемент был "разбит" на два по пробелу.
# Элемент 4: ', длина: 1. # Завершающая кавычка попала в отдельный элемент.

# В Элементе 1 были удалены начальная и завершающая "строгие" кавычки.
# Хотя здесь и не показано, но начальные и завершающие пробелы также удаляются.
# Теперь, когда содержимое строки установлено, Bash всегда, внутри, будет
# "строго" окавычивать содержимое строки, на протяжении всей операции

# Зачем это нужно?
# В нашем случае, в конструкции "$(_pls 'Hello ${Me}')":
# " ... " -> Требуется интерпретация (экспансия), кавычки удаляются.
# $( ... ) -> Замещается результатом выполнения ..., пустая строка.
# _pls ' ... ' -> вызов функции со строковым аргументом, кавычки удаляются.
# Возвращаемый результат включает в себя "строгие" кавычки; НО обработка команды
# уже была завершена выше, так что теперь они становятся частью присваиваемого значения.
#
# Таким образом, ${Me} оказывается частью результата
# и сохраняется в первоначальном виде
# (До тех пор, пока явно не будет указано на необходимость ее интерпретации).

# Дополнительно: Взгляните, что произойдет, если в этих функциях
# "строгие" кавычки ($'\x27') заменить на "мягкие" ($'\x22').
# Интересный результат получится если вообще убрать кавычки.

# _Protect_Literal_String_Test
# # # Раскомментарьте вышестоящую строку, чтобы запретить исполнение вышестоящего кода. # # #

exit 0
</source> 
'''А что делать, если необходимо заставить командный интерпретатор интерпретировать строку'''?
 '''Пример''': '''''A-26. Принудительная интерпретация строк.'''''
<source lang="bash">
#! /bin/bash
# unprotect_literal.sh

# set -vx

:<<-'_UnProtect_Literal_String_Doc'
Copyright (c) Michael S. Zick, 2003; All Rights Reserved
Ограничения: Допускается использовать без каких либо ограничений в любой форме.
Гарантии: Никаких
Издание: $ID$

Этот встроенный документ Bash отправит на устройство '/dev/null'.
(Раскомментарьте команду set, стоящую выше, чтобы убедиться в этом.)

Удалите первую строку (Sha-Bang), если вы собираетесь использовать этот сценарий
в качестве библиотеки. Не забудьте при этом закомментарить примеры
использования процедур (там где это указано).

Порядок использования:
Противоположная по смыслу функции "$(_pls 'Literal String')".
(см. пример protect_literal.sh)

StringVar=$(_upls ProtectedSringVariable)

Назначение:
Выполняет подстановку (интерпретацию) строк в операциях присваивания.

Примечание:
Имена функций (_*) выбраны таким образом, чтобы избежать
конфликтов имен, при подключении данного сценария
к пользовательским сценариям, в качестве библиотеки.

_UnProtect_Literal_String_Doc

_upls() {
local IFS=$'x1B' # Символ \ESC character (не обязательно)
eval echo $@ # Принудительная интерпретация.
}

# :<<-'_UnProtect_Literal_String_Test'
# # # Раскомментарьте вышестоящую строку, чтобы запретить исполнение нижеследующего кода. # # #

_pls() {
local IFS=$'x1B' # Символ \ESC character (не обязательно)
echo $'\x27'$@$'\x27' # Заключить в "строгие" кавычки
}
# Объявим массив тестовых значений.
declare -a arrayZ

# Запишем в массив элементы с разного рода кавычками и экранирующими символами.
arrayZ=( zero "$(_pls 'Hello ${Me}')" 'Hello ${You}' "\'Pass: ${pw}\'" )

# Выполним присвоение одного массива другому.
declare -a array2=( ${arrayZ[@]} )

# В результате должно получиться:
# - - Тест #3 - -
# Элемент 0: zero, длина: 4. # Наш маркер.
# Элемент 1: Hello ${Me}, длина: 11. # Вполне предсказуемый результат.
# Элемент 2: Hello, длина: 5. # ${You} — была интерпретирована.
# # а на её место подставлена пустая строка
# Элемент 3: 'Pass:, длина: 6. # Элемент был "разбит" на два по пробелу.
# Элемент 4: ', длина: 1. # Завершающая кавычка попала в отдельный элемент.

# set -vx

# Инициализируем переменную 'Me' каким-нибудь значением
# чтобы увидеть последующую её интерпретацию.

Me="to the array guy."

# Присвоим результат принудительной интерпретации другой переменной.
newVar=$(_upls ${array2[1]})

# И посмотрим, что получилось.
echo $newVar

# Так ли необходима эта функция?
newerVar=$(eval echo ${array2[1]})
echo $newerVar

# Оказывается совсем не обязательно, но функция _upls делает сценарий
# более понятным.

# Она поможет в том случае, если вдруг забудется смысл конструкции
# $(eval echo ... ).

# Что произойдет, если часть строки,
# которая требует дополнительной интерпретации, окажется неинициализированной?
unset Me
newestVar=$(_upls ${array2[1]})
echo $newestVar

# Просто и со вкусом! Никаких сообщений, никаких предупреждений, никаких ошибок.

# Для чего все это?
# Одна из основных проблем в Bash — невозможность записать в переменные
# некоторые последовательности символов
#
# Теперь эта проблема разрешается восемью строчками кода
# (и четырьмя страницами описания).

# Где это можно использовать?
# Для динамической генерации содержимого Web-страниц,
# в виде массивов строк.

# Содержимое таких страниц может генерироваться командой Bash 'eval'
# Я совсем не призываю заменить PHP, просто высказал интересную мысль.
###

# UnProtectLiteralStringTest

# # # Раскомментарьте вышестоящую строку, чтобы запретить исполнение вышестоящего кода. # # #

exit 0
</source> 
'''В завершение этого раздела, бросим краткий взгляд назад'''...
 '''Пример''': '''''A-27. Повторение основ.'''''
<source lang="bash">
#!/bin/bash
# basics-reviewed.bash

# Расширение файла == *.bash == сценарий, использующий особенности Bash

# Copyright (c) Michael S. Zick, 2003; All rights reserved.
# License: Use in any form, for any purpose.
# Издание: $ID$
#
# Правка, с целью улучшения оформления, выполнена автором книги.
# ("Advanced Bash Scripting Guide")

# Этот сценарий тестировался в Bash версий 2.04, 2.05a и 2.05b.
# Он может не работать в более ранних версиях.
# Этот сценарий умышленно генерирует ошибку
# "command not found". См. строку 394.

# Ведущий разработчик Bash, Chet Ramey, обязался исправить эту проблему
# в следующих версиях Bash.

###-------------------------------------------###
### Сценарий выводит много информации на ###
### экран, поэтому запускайте его в конвейере ###
### с командой more ###
### ###
### Кроме того, вы можете перенаправить ###
### вывод в файл, с целью последующего ###
### изучения ###
###-------------------------------------------###

# Большая часть из приводимых здесь моментов описывается
# в вышеупомянутой книге "Advanced Bash Scripting Guide."
# Этот сценарий, по сути можно расценивать как своего рода презентацию.
# -- msz

# Переменные не типизированы, если не указано обратное.

# Соглашения по именованию переменных.
# Имена переменных не должны начинаться с цифровых символов.
# Имена дескрипторов файлов (как например: 2>&1)
# должны содержать ТОЛЬКО цифры.

# Параметры и элементы массивов Bash — пронумерованы.
# (Параметры, в этом смысле, очень похожи на массивы.)

# Переменные в Bash могут иметь неопределенное значение.
unset VarNull

# Переменные в Bash могут быть определены, но содержать "пустое" (null) значение.
VarEmpty=''

# Переменные могут быть определены и содержать некоторое, непустое значение
VarSomething='Literal'

# Переменные могут хранить:
# * Целое 32-битовое число со знаком
# * Строку символов
# Переменные могут быть массивом.

# Строки могут содержать пробелы и интерпретироваться
# как вызов функции с аргументами.

# Имена переменных и имена функций
# находятся в разных пространствах имен (namespaces).

# Переменные могут быть объявлены массивами как явно, так и неявно
# в зависимости от семантики операции присваивания.
# Явно:
declare -a ArrayVar
# Команда echo — внутренняя команда.

echo $VarSomething
# Команда printf — внутренняя команда.

# здесь %s интерпретируется как строка формата
printf %s $VarSomething # Перевод строки отсутствует, ничего не выводится.
echo # Выводит только перевод строки.

# Интерпретатор Bash различает отдельные слова по символу пробела между ними.
# Поэтому наличие или отсутствие пробела — очень важный признак.
# (В общем случае это так, но есть и исключения из правил.)

# Символ "доллара" ($) интерпретируется как: Content-Of (содержимое для ...).

# Расширенный синтаксис, с использованием символа "доллара":
echo ${VarSomething}

# Здесь, конструкция ${ ... }, позволяет указывать
# не только имена переменных.
# Как правило, запись $VarSomething
# всегда может быть представлена в виде : ${VarSomething}.

# Чтобы увидеть следующие операции в действии — вызовите сценарий
# с несколькими входными аргументами.

# За пределами двойных кавычек, специальные символы @ и *
# имеют идентичное назначение.
# Может произноситься как: All-Elements-Of (Все-Элементы-Для).

# Если имя переменной не указано, то эти специальные символы
# применяются к предопределенным переменным Bash.

echo $* # Все входные параметры сценария или функции
echo ${*} # То же самое
# Bash запрещает подстановку имён файлов в вышеупомянутых конструкциях.

# Ссылка на Все-Элементы-Для
echo $@ # то же самое, что и выше
echo ${@} # то же самое

# Внутри двойных кавычек, поведение символов @ и *
# зависит от установки переменной IFS (Input Field Separator — Разделитель Полей).
# Ссылка на Все-Элементы-Для, внутри двойных кавычек, работает точно так же.

# Обращение к имени переменной означает получение
# всех элементов (символов) строки.

# Для обращения к отдельным элементам (символам) строки,
# может использоваться расширенный синтаксис (см. ниже).

# Обращение к имени переменной-массива в Bash
# означает обращение к нулевому элементу массива,
# а НЕ к ПЕРВОМУ ОПРЕДЕЛЕННОМУ или к ПЕРВОМУ ИНИЦИАЛИЗИРОВАННОМУ элементу.

# Для обращения к другим элементам массива, необходимо явное указание элемента,
# это означает, что ДОЛЖЕН использоваться расширенный синтаксис.
# В общем случае: ${name[subscript]}.

# Для строк может использоваться такая форма записи: ${name:subscript},
# а также для обращения к нулевому элементу массива.

# Массивы в Bash реализованы как связанные списки,
# а не как фиксированная область памяти, что характерно для некоторых
# языков программирования.

# Характеристики массивов в Bash:
# -------------------------------

# Если не определено иначе, индексация массивов в Bash
# начинается с нуля: [0]
# Это называется "индексация с нуля".
###
# Если не указано иначе, массивы в Bash являются упакованными
# (т.е. массивы просто не содержат элементов с отсутствующими индексами).
###
# Отрицательные индексы недопустимы.
###
# Элементы массива не обязательно должны быть одного и того же типа.
###
# Элементы массива могут быть неинициализированы.
# Т.е. массив может быть "разреженным"
###
# Элементы массива могут быть инициализированы пустым значением.
###
# Элементы массива могут содержать:
# * Целое 32-битовое число со знаком
# * Строку
# * Форматированную строку, которая выглядит
# как вызов к функции с параметрами
###
# Инициализированные элементы массива могут быть деинициализированы (unset).
# Т.е. массив может быть переупакован так,
# что он не будет содержать элемента с данным индексом.
###
# К массиву могут добавляться дополнительные элементы,
# не определенные ранее.
###
# По этим причинам я называю массивы Bash — "Bash-массивами" ("Bash-Arrays").
#
# -- msz

# Демонстрация вышесказанного — инициализируем ранее объявленный массив ArrayVar
# как "разреженный" массив.
# (команда 'unset ... ' используется для демонстрации вышесказанного.)

unset ArrayVar[0] # Для демонстрации
ArrayVar[1]=one # Без кавычек
ArrayVar[2]='' # Инициализация пустым значением
unset ArrayVar[3] # Для демонстрации
ArrayVar[4]='four' # В кавычках

# Строка формата %q — трактуется как: Quoted-Respecting-IFS-Rules
# (в соответствии с установками IFS).

echo
echo '- - Вне двойных кавычек - -'
###
printf %q ${ArrayVar[*]} # Шаблон "Все-Элементы-Для"
echo
echo 'команда echo:'${ArrayVar[*]}
###
printf %q ${ArrayVar[@]} # "Все-Элементы-Для"
echo
echo 'команда echo:'${ArrayVar[@]}

# Двойные кавычки используются для разрешения операции подстановки
# внутри кавычек.
# Существует пять самых распространенных случаев,
# зависящих от установок переменной IFS.

echo

echo '- - В двойных кавычках - По-умолчанию IFS содержит пробел-табуляцию-перевод строки- -'
IFS=$'\x20'$'\x09'$'\x0A' # Три байта, и именно в таком порядке.

printf %q "${ArrayVar[*]}" # Шаблон "Все-Элементы-Для"
echo
echo 'команда echo:'"${ArrayVar[*]}"
###
printf %q "${ArrayVar[@]}" # "Все-Элементы-Для"
echo
echo 'команда echo:'"${ArrayVar[@]}"

echo
echo '- - В двойных кавычках - Первый символ в IFS: ^ - -'
# Любой печатаемый, непробельный символ, дает тот же эффект.
IFS='^'$IFS # ^ + пробел табуляция перевод строки###
printf %q "${ArrayVar[*]}" # Шаблон "Все-Элементы-Для"
echo
echo 'команда echo:'"${ArrayVar[*]}"
###
printf %q "${ArrayVar[@]}" # "Все-Элементы-Для"
echo
echo 'команда echo:'"${ArrayVar[@]}"

echo
echo '- - В двойных кавычках - IFS не содержит пробела - -'
IFS='^:%!'
###
printf %q "${ArrayVar[*]}" # Шаблон "Все-Элементы-Для"
echo
echo 'команда echo:'"${ArrayVar[*]}"
###
printf %q "${ArrayVar[@]}" # "Все-Элементы-Для"
echo
echo 'команда echo:'"${ArrayVar[@]}"

echo
echo '- - В двойных кавычках - переменная IFS пуста - -'
IFS=''
###
printf %q "${ArrayVar[*]}" # Шаблон "Все-Элементы-Для"
echo
echo 'команда echo:'"${ArrayVar[*]}"
###
printf %q "${ArrayVar[@]}" # "Все-Элементы-Для"
echo
echo 'команда echo:'"${ArrayVar[@]}"

echo
echo '- - В двойных кавычках - переменная IFS не определена - -'
unset IFS
###
printf %q "${ArrayVar[*]}" # Шаблон "Все-Элементы-Для" All-Elements-Of
echo
echo 'команда echo:'"${ArrayVar[*]}"
###
printf %q "${ArrayVar[@]}" # "Все-Элементы-Для"
echo
echo 'команда echo:'"${ArrayVar[@]}"

# Вернём переменную IFS в первоначальное состояние,
# записав в неё значение по-умолчанию.

IFS=$'\x20'$'\x09'$'\x0A' # точно в таком порядке.

# Интерпретация результатов, полученных выше:
# Форма ввода по шаблону "Все-Элементы-Для" зависит от содержимого переменной
###
# Простой вывод "Всех-Элементов-Для" не зависит от содержимого переменной IFS.
###
# Обратите внимание на различия, имеющиеся в выводе
# от команд echo и printf с форматом %q.

# Давайте вспомним:
# Параметры очень похожи на массивы и имеют сходное поведение.
###
# Примеры выше показывают, что для того, чтобы вывести разреженный
# массив полностью, необходимо писать дополнительный код.
###

# Длина строки равна количеству ненулевых элементов (символов):
echo
echo '- - Имя переменной употребляется вне кавычек - -'
echo 'Количество ненулевых символов: '${#VarSomething}'.'

# test='Lit'$'\x00''eral' # $'\x00' — нулевой (null) символ.
# echo ${#test} # Что получится?

# Длина массива равна количеству инициализированных элементов,
# включая элементы, инициализированные пустыми значениями.
echo
echo 'Количество инициализированных элементов в массиве: '${#ArrayVar[@]}'.'
# Это НЕ максимальный индекс массива (4).
# Это НЕ ширина диапазона (1 . . 4 включительно).
# Это длина связного списка.
###
# Максимальный номер индекса массива и диапазон индексов
# могут быть найдены, но для этого потребуется дополнительный код.

# Длина строки равна количеству ненулевых элементов (символов):
echo
echo '- - Имя переменной употребляется в кавычках - -'
echo 'Количество непустых символов: '"${#VarSomething}"'.'

# Длина массива равна количеству инициализированных элементов,
# включая элементы, инициализированные пустыми значениями.
echo
echo 'Количество инициализированных элементов в массиве: '"${#ArrayVar[*]}"'.'

# Вывод: Конструкция ${# ... } не производит подстановку.
# Совет:
# Всегда используйте символ All-Elements-Of (Все-Элементы-Для)
# если желаете получить результат, не зависящий от содержимого переменной IFS.

# Определим простую функцию.
# Я включил в имя функции символ подчеркивания
# чтобы как-то обозначить, что это функция, а не переменная.
###
# Bash различает имена функций и переменных,
# размещая из в различных пространствах имён.
###

_simple() {
echo -n 'SimpleFunc'$@ # Символ перевода строки в любом случае
} # будет "съеден".
# Конструкция ( ... ) вызывает команду или функцию.
# Форма записи $( ... ) произносится как: Result-Of (Результат-Выполнения).

# Вызовем функцию _simple
echo
echo '- - Результат работы функции _simple - -'

_simple # Попробуйте передать несколько аргументов.
echo
# или
(_simple) # Попробуйте передать несколько аргументов.
echo

echo '- Существует ли переменная с таким именем? -'
echo $_simple not defined # Нет переменной с таким именем.

# Обращение к результату выполнения функции _simple
# (будет получено сообщение об ошибке)
###
$(_simple) # Генерирует сообщение об ошибке:
# line 394: SimpleFunc: command not found
# ---------------------------------------
echo
###

# Причина ошибки вполне очевидна: результат работы функции _simple не есть
# ни команда Bash, ни имя определенной ранее функции.
###
# Этот пример показывает, что вывод от функции _simple подвергается
# дополнительной интерпретации.
###
# Вывод:
# Функция может использоваться для генерации команд Bash.

# Простая функция, которая выводит команду bash:
###
_print() {
echo -n 'printf %q '$@
}

echo '- - Результат работы функции _print - -'
_print parm1 parm2 # Простой вывод — НЕ команда.
echo
$(_print parm1 parm2) # Исполняет команду printf %q parm1 parm2
# См. пример с IFS выше
# на предмет дополнительных возможностей.
echo
$(_print $VarSomething) # Вполне предсказуемый результат.
echo

# Переменные-функции
# ------------------

echo
echo '- - Переменные-функции - -'
# Переменная может хранить целое число, строку или массив.
# Строка может интерпретироваться как вызов функции.

# set -vx # Раскомментарьте при желании

declare -f funcVar # в пространстве имён функций!

funcVar=_print # Записать имя функции.
$funcVar parm1 # Аналогично вызову функции _print.

echo

funcVar=$(_print ) # Результат работы функции.
$funcVar # Нет ни ввода, ни вывода.
$funcVar $VarSomething # Предсказуемый результат.
echo

funcVar=$(_print $VarSomething) # Здесь выполняется подстановка
# значения переменной $VarSomething.

$funcVar # Содержимое переменной $VarSomething
echo # стало частью переменной $funcVar

funcVar="$(_print $VarSomething)" # Здесь выполняется подстановка
# значения переменной $VarSomething.

$funcVar # Содержимое переменной $VarSomething
echo # стало частью переменной $funcVar

# Различия в применении или неприменении двойных кавычек
# объясняются в примере "protect_literal.sh".
# В первом случае Bash обрабатывает строку как два отдельных слова,
# во втором — как одно слово в кавычках с пробелом внутри слова.

# Отложенная подстановка
# ----------------------

echo
echo '- - Отложенная подстановка - -'
funcVar="$(_print '$VarSomething')" # Подстановка значения переменной не производится.
eval $funcVar # Подстановка производится ЗДЕСЬ.
echo

VarSomething='NewThing'
eval $funcVar # Подстановка производится ЗДЕСЬ.
echo

# Восстановим прежнее значение переменной VarSomething.
VarSomething=Literal
# В примерах "protect_literal.sh" и "unprotect_literal.sh"
# вы найдёте две функции, которые выполняют отложенную подстановку
# значений переменных.

# ОБЗОР:
# -----

# Строки могут рассматриваться как классический массив элементов-символов.
# Строковые операции воздействуют на все элементы (символы) строки
###
# Запись: ${array_name[@]} представляет все элементы
# Bash-Массива: array_name.
###
# Строковые операции, в расширенном синтаксисе, могут манипулировать
# всеми элементами массива сразу.
###
# Эта способность может рассматриваться как операция For-Each над вектором строк.
###
# Параметры подобны массивам.
# Различия в параметрах для функции и сценария касаются только параметра
# ${0}, который никогда не изменяется.
###
# Нулевой параметр сценария содержит имя файла сценария
###
# Нулевой параметр функции НЕ СОДЕРЖИТ имени функции.
# Имя функции хранится в служебной переменной $FUNCNAME.
###

echo
echo '- - Тест (без изменения содержимого переменной) - -'
echo '- неинициализированная переменная -'
echo -n ${VarNull-'NotSet'}' ' # NotSet
echo ${VarNull} # только перевод строки
echo -n ${VarNull:-'NotSet'}' ' # NotSet

echo ${VarNull} # только перевод строкиecho '- "пустая" переменная -'
echo -n ${VarEmpty-'Empty'}' ' # только пробел
echo ${VarEmpty} # только перевод строки
echo -n ${VarEmpty:-'Empty'}' ' # Empty
echo ${VarEmpty} # только перевод строки

echo '- непустая переменная -'
echo ${VarSomething-'Content'} # Literal
echo ${VarSomething:-'Content'} # Literal

echo '- Разреженный массив -'
echo ${ArrayVar[@]-'not set'}

# ASCII-Art time
# State Y==yes, N==no
# - :-
# Unset Y Y ${# ... } == 0
# Empty N Y ${# ... } == 0
# Contents N N ${# ... } > 0

# Либо первая, либо вторая часть операции подстановки параметра по-умолчанию
# может быть командой или вызовом функции.
echo
echo '- - Тест 1, не определенная переменная - -'
declare -i t
_decT() {
t=$t-1
}
# Для не определенной переменной: t == -1
t=${#VarNull} # t == 0
${VarNull- _decT } # Вызов функции, теперь t == -1.
echo $t

# "Пустая" переменная: t == 0
t=${#VarEmpty} # t == 0
${VarEmpty- _decT } # Функция _decT НЕ вызывается.
echo $t

# Непустая переменная: t == число непустых символов
VarSomething='_simple' # Записать имя функции в переменную.
t=${#VarSomething} # ненулевая длина
${VarSomething- _decT } # Вызывается функция _simple.
echo $t # Обратите внимание на вывод.

# Упражнение: Разберитесь в этом примере.
unset t
unset _decT
VarSomething=Literal

echo
echo '- - Тест (с изменением содержимого переменной) - -'
echo '- Присвоить, если переменная не определена -'
echo -n ${VarNull='NotSet'}' ' # NotSet NotSet
echo ${VarNull}
unset VarNull

echo '- Присвоить, если переменная не определена -'
echo -n ${VarNull:='NotSet'}' ' # NotSet NotSet
echo ${VarNull}
unset VarNull

echo '- Не присваивать, если переменная пуста -'
echo -n ${VarEmpty='Empty'}' ' # только пробел
echo ${VarEmpty}
VarEmpty=''

echo '- Присвоить, если переменная пуста -'
echo -n ${VarEmpty:='Empty'}' ' # Empty Empty
echo ${VarEmpty}
VarEmpty=''

echo '- Не изменять, если переменная не пуста -'
echo ${VarSomething='Content'} # Literal
echo ${VarSomething:='Content'} # Literal

# "Разреженные" Bash-Массивы
###
# Bash-Массивы не содержат пустых элементов, и индексация их,
# если не оговорено иное, начинается с нуля.
###
# Инициализируем массив ArraySparse как раз тем способом,
# когда "оговорено иное". Ниже приведен один из вариантов:
###
echo
declare -a ArraySparse
ArraySparse=( [1]=one [2]='' [4]='four' )
# [0]=нет элемента, [2]=пустой элемент, [3]=нет элемента

echo '- - Разреженный массив - -'
# В двойных кавычках, значение IFS -- по-умолчанию, Все-Элементы-Для

IFS=$'\x20'$'\x09'$'\x0A'printf %q "${ArraySparse[*]}"
echo

# Обратите внимание на отсутствие различий в том, как выводятся отсутствующий
# и пустой элементы массива.
# Оба выводятся как экранированные пробелы.
###
# Не упустите из виду и то, что все неопределенные элементы массива,
# предшествующие первому инициализированному элементу, не выводятся
###
# Замечание о таком "поведении" Bash, версий 2.04, 2.05a и 2.05b,
# было передано разработчикам has been reported
# и возможно будет изменено в последующих версиях Bash.

# Чтобы вывести содержимое такого разреженного массива без изменений
# требуется некоторое количество усилий.
# Вот один из возможных вариантов вывода такого массива:
###
# local l=${#ArraySparse[@]} # Количество инициализированных элементов
# local f=0 # Количество найденных индексов
# local i=0 # текущий индекс

( # Анонимная функция
for (( l=${#ArraySparse[@]}, f = 0, i = 0 ; f < l ; i++ ))
do
# 'if defined then...'
${ArraySparse[$i]+ eval echo '\ ['$i']='${ArraySparse[$i]} ; (( f++ )) }
done
)

# Важно:
# Команда "read -a array_name" начинает заполнять массив
# array_name с нулевого элемента.
# ArraySparse -- не содержит нулевого элемента.
###
# Для выполнения операций над разреженными массивами,
# такими как чтение/запись массива из/в файла
# программист должен сам создать программный код, который
# будет удовлетворять его потребности.
###
# Упражнение: разберитесь в следующем примере самостоятельно.

unset ArraySparse

echo
echo '- - Замена по условию (замена не производится)- -'
echo '- Не изменять если переменная не определена -'
echo -n ${VarNull+'NotSet'}' '
echo ${VarNull}
unset VarNull

echo '- Не изменять если переменная не определена -'
echo -n ${VarNull:+'NotSet'}' '
echo ${VarNull}
unset VarNull

echo '- Изменить если переменная пуста -'
echo -n ${VarEmpty+'Empty'}' ' # Empty
echo ${VarEmpty}
VarEmpty=''

echo '- Не изменять если переменная пуста -'
echo -n ${VarEmpty:+'Empty'}' ' # Только пробел
echo ${VarEmpty}
VarEmpty=''

echo '- Изменить, если переменная не пуста -'

echo -n ${VarSomething+'Content'}' ' # Content Literal
echo ${VarSomething}

# Вызов функции
echo -n ${VarSomething:+ $(_simple) }' ' # SimpleFunc Literal
echo ${VarSomething}
echo
echo '- - Разреженный массив - -'
echo ${ArrayVar[@]+'Empty'} # An array of 'Empty'(ies)
echo

echo '- - Тест 2, неопределенные переменные - -'

declare -i t
_incT() {
t=$t+1
}

# Обратите внимание:
# Тот же самый тест, что и в случае с разреженными массивами

# Неопределенная переменная: t == -1
t=${#VarNull}-1 # t == -1
${VarNull+ _incT } # Функция не вызывается.

echo $t' Переменная не определена'

# Пустая переменная: t == 0
t=${#VarEmpty}-1 # t == -1
${VarEmpty+ _incT } # Вызов функции.
echo $t' Переменная пуста'
# Переменная не пуста: t == (количество непустых символов)
t=${#VarSomething}-1 # количество_непустых_символов минус один
${VarSomething+ _incT } # Вызов функции.
echo $t' Переменная не пуста'

# Операции над элементами массива
# -------------------------------

echo
echo '- - Выборка элементов - -'

# Строки, массивы и позиционные параметры
# Чтобы увидеть работу сценария с позиционными параметрами,
# вызовите его с несколькими аргументами

echo '- Все -'
echo ${VarSomething:0} # все не пустые символы
echo ${ArrayVar[@]:0} # все не пустые элементы
echo ${@:0} # все не пустые параметры;
# параметр [0] игнорируется
echo
echo '- Все после -'
echo ${VarSomething:1} # все не пустые символы, стоящие после [0]
echo ${ArrayVar[@]:1} # все не пустые элементы, стоящие после [0]
echo ${@:2} # все не пустые параметры, стоящие после [1]

echo
echo '- Диапазон символов -'
echo ${VarSomething:4:3} # ral
# Три символа, следующие за символом [3]
echo '- Разреженный массив -'
echo ${ArrayVar[@]:1:2} # four - Единственный непустой элемент.

# Чтобы убедиться в том, что Bash в данной ситуации рассматривает только
# непустые элементы

# printf %q "${ArrayVar[@]:0:3}" # Попробуйте раскомментарить эту строку

# Версии Bash 2.04, 2.05a и 2.05b,
# работают с разреженными массивами не так как ожидается.
#
# Chet Ramey обещал исправить это в последующих версиях Bash.

echo '- Неразреженный массив -'
echo ${@:2:2} # За параметром [1] следуют ещё два параметра

# Простые примеры со строками и массивами строк:
stringZ=abcABC123ABCabc
arrayZ=( abcabc ABCABC 123123 ABCABC abcabc )
sparseZ=( [1]='abcabc' [3]='ABCABC' [4]='' [5]='123123' )

echo
echo ' - - Простая строка - -'$stringZ'- - '
echo ' - - Простой массив - -'${arrayZ[@]}'- - '
echo ' - - Разреженный массив - -'${sparseZ[@]}'- - '
echo ' - [0]==нет элемента, [2]==нет элемента, [4]==пустой элемент - '
echo ' - [1]=abcabc [3]=ABCABC [5]=123123 - '
echo ' - количество инициализированных элементов: '${#sparseZ[@]}

echo
echo '- - Префиксы - -'
echo '- - Шаблон должен совпадать с первым символом строки. - -'
echo '- - Шаблон может быть строкой или результатом работы функции. - -'
echo

# Функция, результатом работы которой является обычная строка
_abc() {
echo -n 'abc'
}

echo '- Кратчайший префикс -'
echo ${stringZ#123} # Без изменения — не префикс.
echo ${stringZ#$(abc)} # ABC123ABCabc
echo ${arrayZ[@]#abc} # Применяется к каждому элементу массива.

# Chet Ramey обещал исправить в последующих версиях Bash.
# echo ${sparseZ[@]#abc} # В версии 2.05b — core dumps.

# -Это было бы здорово- First-Subscript-Of (Первый-Индекс-Массива)
# echo ${#sparseZ[@]#*} # line 805: ${#sparseZ[@]#*}: bad substitution.

echo
echo '- Наибольший префикс -'
echo ${stringZ##1*3} # Без изменения — не префикс.
echo ${stringZ##a*C} # abc
echo ${arrayZ[@]##a*c} # ABCABC 123123 ABCABC
# Chet Ramey обещал исправить в последующих версиях Bash.
# echo ${sparseZ[@]##a*c} # В версии 2.05b — core dumps.

echo
echo '- - Суффиксы - -'
echo '- - Шаблон должен совпадать с последним символом строки. - -'
echo '- - Шаблон может быть строкой или результатом работы функции. - -'
echo
echo '- Кратчайший суффикс -'
echo ${stringZ%1*3} # Без изменения — не суффикс.
echo ${stringZ%$(_abc)} # abcABC123ABC
echo ${arrayZ[@]%abc} # Применяется к каждому элементу массива.

# Chet Ramey обещал исправить в последующих версиях Bash.
# echo ${sparseZ[@]%abc} # В версии 2.05b — core dumps.

# -Это было бы здорово- Last-Subscript-Of (Последний-Индекс-Массива)
# echo ${#sparseZ[@]%*} # line 830: ${#sparseZ[@]%*}: bad substitution

echo
echo '- Наибольший суффикс -'
echo ${stringZ%%1*3} # Без изменения — не суффикс.
echo ${stringZ%%b*c} # a
echo ${arrayZ[@]%%b*c} # a ABCABC 123123 ABCABC a

# Chet Ramey обещал исправить в последующих версиях Bash.
# echo ${sparseZ[@]%%b*c} # В версии 2.05b — core dumps.

echo
echo '- - Замена подстроки - -'
echo '- - Подстрока может находиться в любом месте в строке. - -'
echo '- - Первый описатель задает шаблон поиска - -'
echo '- - Шаблон может быть строкой или результатом работы функции. - -'
echo '- - Второй описатель может быть строкой или результатом работы функции. - -'
echo '- - Второй описатель может быть опущен. В результате получится:'
echo ' Заменить-Ничем (Удалить) - -'
echo

# Функция, результатом работы которой является обычная строка
_123() {
echo -n '123'
}

echo '- Замена первого вхождения -'
echo ${stringZ/$(_123)/999} # Подстрока 123 заменена на 999).
echo ${stringZ/ABC/xyz} # xyzABC123ABCabc
echo ${arrayZ[@]/ABC/xyz} # Применяется ко всем элементам массива.
echo ${sparseZ[@]/ABC/xyz} # Работает так как и ожидается.

echo
echo '- Удаление первого вхождения -'
echo ${stringZ/$(_123)/}
echo ${stringZ/ABC/}
echo ${arrayZ[@]/ABC/}
echo ${sparseZ[@]/ABC/}

# Замещающий элемент необязательно должен быть строкой,
# допускается употреблять результат функции.
# Это применимо ко всем формам замены.

echo
echo '- Замена первого вхождения результатом работы функции -'
echo ${stringZ/$(_123)/$(_simple)} # Работает так как и ожидается.
echo ${arrayZ[@]/ca/$(_simple)} # Применяется ко всем элементам массива.
echo ${sparseZ[@]/ca/$(_simple)} # Работает так как и ожидается.

echo
echo '- Замена всех вхождений -'
echo ${stringZ//[b2]/X} # все символы b и 2 заменяются символом X
echo ${stringZ//abc/xyz} # xyzABC123ABCxyz
echo ${arrayZ[@]//abc/xyz} # Применяется ко всем элементам массива.
echo ${sparseZ[@]//abc/xyz} # Работает так как и ожидается.

echo
echo '- Удаление всех вхождений -'
echo ${stringZ//[b2]/}
echo ${stringZ//abc/}
echo ${arrayZ[@]//abc/}
echo ${sparseZ[@]//abc/}

echo
echo '- - Замена префикса - -'
echo '- - Шаблон должен совпадать с первым символом строки. - -'
echo

echo '- - Замена префикса - -'
echo ${stringZ/#[b2]/X} # Без изменения — не префикс.
echo ${stringZ/#$(_abc)/XYZ} # XYZABC123ABCabc
echo ${arrayZ[@]/#abc/XYZ} # Применяется ко всем элементам массива.
echo ${sparseZ[@]/#abc/XYZ} # Работает так как и ожидается.

echo
echo '- Удаление префикса -'
echo ${stringZ/#[b2]/}
echo ${stringZ/#$(_abc)/}
echo ${arrayZ[@]/#abc/}
echo ${sparseZ[@]/#abc/}

echo
echo '- - Замена суффикса - -'
echo '- - Шаблон должен совпадать с последним символом строки. - -'
echo

echo '- - Замена суффикса - -'
echo ${stringZ/%[b2]/X} # Без изменения — не суффикс.
echo ${stringZ/%$(_abc)/XYZ} # abcABC123ABCXYZ
echo ${arrayZ[@]/%abc/XYZ} # Применяется ко всем элементам массива.
echo ${sparseZ[@]/%abc/XYZ} # Работает так как и ожидается.

echo
echo '- Удаление суффикса -'
echo ${stringZ/%[b2]/}
echo ${stringZ/%$(_abc)/}
echo ${arrayZ[@]/%abc/}
echo ${sparseZ[@]/%abc/}

echo
echo '- - Специальный случай -- пустой шаблон поиска - -'
echo

echo '- Префикс -'
# пустой шаблон означает простую вставку в начало строки
echo ${stringZ/#/NEW} # NEWabcABC123ABCabc
echo ${arrayZ[@]/#/NEW} # Применяется ко всем элементам массива.
echo ${sparseZ[@]/#/NEW} # И к неинициализированным элементам тоже

echo
echo '- Суффикс -'
# пустой шаблон означает простое добавление в конец строки
echo ${stringZ/%/NEW} # abcABC123ABCabcNEW
echo ${arrayZ[@]/%/NEW} # Применяется ко всем элементам массива.
echo ${sparseZ[@]/%/NEW} # И к неинициализированным элементам тоже

echo
echo '- - Специальный случай оператора For-Each - -'
echo '- - - - This is a nice-to-have dream - - - -'
echo

_GenFunc() {
echo -n ${0} # Только как иллюстрация.
# Фактически здесь может стоять любое другое выражение.
}

# Все вхождения, совпадающие с шаблоном "*"
# В настоящее время, шаблон //*/ не совпадает с пустыми
# и неинициализированными элементами.
# В то время как шаблоны /#/ и /%/ совпадают с пустыми и не совпадают
# с неинициализированными элементами.

echo ${sparseZ[@]//*/$(_GenFunc)}

exit 0
</source> 

= Приложение B. Справочная информация =
В нижеследующем справочнике представлена информация, касающаяся отдельных моментов написания сценариев на языке командной оболочки ''Bash''. 
 '''Таблица B-1. Переменные специального назначения'''
{| class="wikitable" style="margin-left: 365px; margin-right: 0px;"
|-
! '''''Переменная''''' !! '''''Описание'''''
|-
| style="text-align:center;" | '''$0''' || ''Имя файла сценария''
|-
| style="text-align:center;" | '''$1''' || ''Позиционный параметр #1 (аргумент сценария или функции)''
|-
| style="text-align:center;" | '''$2 - $9''' || ''Позиционные параметры #2 - #9''
|-
| style="text-align:center;" | '''${10}''' || ''Позиционный параметр #10''
|-
| style="text-align:center;" | '''$#''' || ''Количество позиционных параметров''
|-
| style="text-align:center;" | '''"$*"''' || ''Все позиционные параметры''(как одно слово. Необходимо''
''заключать в кавычки, в противном случае будет работать как "$@"'')
|-
| style="text-align:center;" | '''"$@"''' || ''Все позиционные параметры(в виде отдельных строк)''
|-
| style="text-align:center;" | '''${#*}''' || ''Количество позиционных параметров,''
''переданных из командной строки''
|-
| style="text-align:center;" | '''${#@}''' || ''Количество позиционных параметров,''
''переданных из командной строки''
|-
| style="text-align:center;" | '''$?''' || ''Возвращаемое значение (Код возврата последней команды)''
|-
| style="text-align:center;" | '''$$''' || ''Идентификатор процесса — Process ID (PID) сценария''
|-
| style="text-align:center;" | '''$-''' || ''Флаги, переданные сценарию(командой set)''
|-
| style="text-align:center;" | '''$_''' || ''Последний аргумент предыдущей команды''
|-
| style="text-align:center;" | '''$!''' || ''Идентификатор последнего фонового процесса (PID)'''
|}

 '''Таблица B-2. Операции проверки: Двухместные операции'''
{| class="wikitable" style="margin-left: 270px; margin-right: 0px;"
|-
! '''Оператор''' !! '''Значение''' !! '''----''' !! '''Оператор''' !! '''Значение'''
|-
| || || || ||
|-
| <div style="color:blue">'''Арифметическое сравнение''' </div>|| || || <div style="color:blue">'''Сравнение строк'''</div> ||
|-
| style="text-align:center;" | '''''-eq''''' || ''Равно'' || || style="text-align:center;" | '''''=''''' || ''Равно''
|-
| || || || style="text-align:center;" | '''''==''''' || ''Равно''
|-
| style="text-align:center;" | '''''-ne''''' || ''Не равно'' || || style="text-align:center;" | '''''!=''''' || ''Не равно''
|-
| style="text-align:center;" | '''''-lt''''' || ''Меньше'' || || style="text-align:center;" | '''''\<''''' || ''Меньше(в кодах ASCII)''*
|-
| style="text-align:center;" | '''''-le''''' || ''Меньше или равно'' || || ||
|-
| style="text-align:center;" | '''''-gt''''' || ''Больше'' || || style="text-align:center;" | '''''\>''''' || ''Больше(в кодах ASCII)''*
|-
| style="text-align:center;" | '''''-ge''''' || ''Больше или равно'' || || ||
|-
| || || || style="text-align:center;" | '''''-z''''' || ''Пустая строка''
|-
| || || || style="text-align:center;" | '''''-n''''' || ''Не пустая строка''
|-
| || || || ||
|-
| <div style="color:blue">'''Арифметическое сравнение''' </div>|| <div style="color:blue">'''В двойных круглых скобках((... )) </div>|| || ||
|-
| style="text-align:center;" | '''''>''''' || ''Больше'' || || ||
|-
| style="text-align:center;" | '''''>=''''' || ''Больше или равно'' || || ||
|-
| style="text-align:center;" | '''''<''''' || ''Меньше'' || || ||
|-
| style="text-align:center;" | '''''<=''''' || Меньше или равно|| || ||
|}
::::::::::::: *'''При использовании двойных квадратных скобок''' ''<nowiki>[[</nowiki>...<nowiki>]]</nowiki>'', '''необходимо использовать экранирующий символ —''' '''\'''. 

 '''Таблица B-3. Операции проверки: Файлы'''
{| class="wikitable" style="margin-left: 140px; margin-right: 0px;"
|-
! '''''Оператор''''' !! '''''Что проверяется''''' !! '''''----''''' !! '''''Оператор''''' !! '''''Что проверяется'''''
|-
| style="text-align:center;" | '''-e''' || ''Файл существует'' || || style="text-align:center;" | '''-s''' || ''Файл не нулевой длины''
|-
| style="text-align:center;" | '''-f''' || ''Обычный файл'' || || ||
|-
| style="text-align:center;" | '''-d''' || ''Файл является каталогом'' || || style="text-align:center;" | '''-r''' || ''Файл доступен для чтения''
|-
| style="text-align:center;" | '''-h''' || ''Файл является символической ссылкой'' || || style="text-align:center;" | '''-w''' || ''Файл доступен для записи''
|-
| style="text-align:center;" | '''-L''' || ''Файл является символической ссылкой'' || || style="text-align:center;" | '''-x''' || ''Файл доступен для исполнения''
|-
| style="text-align:center;" | '''-b''' || ''Файл блочного устройства'' || || ||
|-
| style="text-align:center;" | '''-c''' || ''Файл символьного устройства'' || || style="text-align:center;" | '''-g''' || ''Установлен флаг sgid''
|-
| style="text-align:center;" | '''-p''' || ''Файл является каналом (pipe)'' || || style="text-align:center;" | '''-u''' || ''Установлен флаг suid''
|-
| style="text-align:center;" | '''-S''' || ''Файл является сокетом (socket)'' || || style="text-align:center;" | '''-k''' || ''Установлен бит "sticky"''
|-
| style="text-align:center;" | '''-t''' || ''Файл связан с терминальным устройством'' || || ||
|-
| || || || ||
|-
| style="text-align:center;" | '''-N''' || ''Файл был модифицирован с момента последнего чтения'' || || style="text-align:center;" | '''F1 -nt F2''' || ''Файл F1 более новый, чем F2''*
|-
| style="text-align:center;" | '''-O''' || ''Вы являетесь владельцем файла'' || || style="text-align:center;" | '''F1 -ot F2''' || ''Файл F1 более старый, чем F2''*
|-
| style="text-align:center;" | '''-G''' || ''Вы принадлежите к той же группе, что и файл || || style="text-align:center;" | '''F1 -ef F2''' || ''Файлы F1 и F2 являются жёсткими''
''ссылками на один тот же файл''
|-
| || || || ||
|-
| style="text-align:center;" | '''!''' || ''"NOT" (логическое отрицание(инверсия) результатов всех вышеприведенных проверок)'' || || ||
|-
|}
::::::::::::: *'''Двухместный оператор (требует наличия двух операндов)'''. 
 '''Таблица B-4. Подстановка параметров и экспансия'''
{| class="wikitable" style="margin-left: 340px; margin-right: 0px;"
|-
! '''''Выражение''''' !! '''''Описание'''''
|-
| style="text-align:center;" | '''${var}''' || ''Значение переменной var, то же, что и $var''
|-
| ||
|-
| style="text-align:center;" | '''${var-DEFAULT}''' || ''Если переменная var не инициализирована, то результатом''
''вычисления выражения является $DEFAULT''*
|-
| style="text-align:center;" | '''${var:-DEFAULT}''' || ''Если переменная var не инициализирована или пуста, то''
''результатом вычисления выражения является $DEFAULT''*
|-
| style="text-align:center;" | '''${var=DEFAULT}''' || ''Если переменная var не инициализирована, то результатом''
''вычисления выражения является $DEFAULT''*
|-
| style="text-align:center;" | '''${var:=DEFAULT}''' || ''Если переменная var не инициализирована, то результатом''
''вычисления выражения является $DEFAULT''*
|-
| ||
|-
| style="text-align:center;" | '''${var+OTHER}''' || ''Если переменная var инициализирована, то результатом вычисления''
''выражения является $OTHER, иначе — пустая строка''
|-
| style="text-align:center;" | '''${var:+OTHER}''' || ''Если переменная var инициализирована set, то результатом вычисления''
''выражения является $OTHER, иначе — пустая строка''
|-
| ||
|-
| style="text-align:center;" | '''${var?ERR_MSG}''' || ''Если переменная var не инициализирована, то выводится $ERR_MSG''*
|-
| style="text-align:center;" | '''${var:?ERR_MSG}''' || ''Если переменная var не инициализирована, то выводится $ERR_MSG''*
|-
| ||
|-
| style="text-align:center;" | '''${!varprefix*}''' || ''Соответствует всем ранее объявленным переменным, чьи имена''
''начинаются с varprefix''
|-
| style="text-align:center;" | '''${!varprefix@}''' || ''Соответствует всем ранее объявленным переменным, чьи имена''
начинаются с varprefix
|}
::::::::::::: *'''Само собой разумеется, если переменная var инициализирована, то результатом выражения будет $var'''. 
 '''Таблица B-5. Операции со строками'''
{| class="wikitable" style="margin-left: 220px; margin-right: 0px;"
|-
! '''''Выражение''''' !! '''''Описание'''''
|-
| style="text-align:center;" | '''${string:position}''' || ''Извлечение подстроки из строки $string,''
''начиная с позиции $position''
|-
| style="text-align:center;" | '''${#string}''' || ''Длина строки $string''
|-
| style="text-align:center;" | '''${string:position:length}''' || ''Извлечение $length символов из строки''
''$string, начиная с позиции $position''
|-
| style="text-align:center;" | '''${string#substring}''' || ''Поиск кратчайшего совпадения по шаблону $substring,''
''в строке $string, поиск ведётся с начала строки''
|-
| style="text-align:center;" | '''${string##substring}''' || ''Поиск самого длинного совпадения по шаблону''
''$substring, в строке $string, поиск ведется с начала строки''
|-
| style="text-align:center;" | '''${string%substring}''' || ''Поиск кратчайшего совпадения по шаблону $substring,''
''в строке $string, поиск ведётся с конца строки''
|-
| style="text-align:center;" | '''${string%%substring}''' || ''Поиск самого длинного совпадения по шаблону''
''$substring, в строке $string, поиск ведётся с конца строки''
|-
| style="text-align:center;" | '''${string/substring/replacement}''' || ''Замена первой, найденной по''
''шаблону $substring, подстроки на подстроку $replacement''
|-
| style="text-align:center;" | '''${string//substring/replacement}''' || ''Замена всех, найденных по''
''шаблону $substring, подстрок на подстроку $replacement''
|-
| style="text-align:center;" | '''${string/#substring/replacement}''' || ''Если в строке $string найдено соответствие шаблону $substring и найденная
''подстрока начинает строку $string, то она заменяется подстрокой $replacement''
|-
| || ''Если в строке $string найдено соответствие шаблону $substring и найденная подстрока''
''заканчивает строку $string, то она заменяется подстрокой $replacement''
|-
| style="text-align:center;" | '''expr match "$string" '$substring' ''' || ''Количество совпадений с шаблоном $substring''*
''в строке $string, поиск начинается с начала строки''
|-
| style="text-align:center;" | '''expr "$string" : '$substring' ''' || ''Количество совпадений с шаблоном $substring''*
''в строке $string, поиск начинается с начала строки''
|-
| style="text-align:center;" | '''expr index "$string" $substring''' || ''Позиция(номер символа), первого найденного''
''совпадения с шаблоном $substring, в строке $string''
|-
| style="text-align:center;" | '''expr substr $string $position $length''' || ''Извлечение $length символов из строки $string,''
''начиная с позиции $position''
|-
| style="text-align:center;" | '''expr match "$string" '$$substring$' ''' || ''Извлечение подстроки с начала строки $string,''
''совпадающей с шаблоном $substring''*
|-
| style="text-align:center;" | '''expr "$string" : '$$substring$' ''' || ''Извлечение подстроки с начала строки $string,''
''совпадающей с шаблоном $substring''*
|-
| style="text-align:center;" | '''expr match "$string" '.*$$substring$' ''' || ''Извлечение подстроки с конца строки $string,''
''совпадающей с шаблоном $substring''*
|-
| style="text-align:center;" | '''expr "$string" : '.*$$substring$' ''' || ''Извлечение подстроки с конца строки $string,''
''совпадающей с шаблоном $substring''*
|}
:::::::::::::::::::::: '''* Где $substring — регулярное выражение'''. 
 '''Таблица B-6. Прочие конструкции'''
{| class="wikitable" style="margin-left: 265px; margin-right: 0px;"
|-
! '''''Выражение''''' !! '''''Описание'''''
|-
| style="text-align:center;" | <div style="color:blue"> '''Квадратные скобки'''</div> ||
|-
| style="text-align:center;" | '''if [ CONDITION ]''' || ''Проверка условия''
|-
| style="text-align:center;" | '''if''' '''<nowiki>[[</nowiki>''' '''CONDITION''' '''<nowiki>]]</nowiki>''' || ''Расширенный синтаксис операции проверки условия''
|-
| style="text-align:center;" | '''Array[1]=element1''' || ''Инициализация массива''
|-
| style="text-align:center;" | '''[a-z]''' || ''Диапазон символов в регулярных выражениях''
|-
| style="text-align:center;" | <div style="color:blue">'''Фигурные скобки'''</div> ||
|-
| style="text-align:center;" | '''${variable}''' || ''Подстановка параметра''
|-
| style="text-align:center;" | '''${!variable}''' || ''Косвенная ссылка на переменную''
|-
| style="text-align:center;" | '''{ command1; command2 }''' || ''Блок кода''
|-
| style="text-align:center;" | '''{string1,string2,string3,...}''' || ''Подстановка''
|-
| style="text-align:center;" | <div style="color:blue">'''Круглые скобки'''</div> ||
|-
| style="text-align:center;" | '''( command1; command2 )''' || ''Группа команд, исполняемая в подоболочке(subshell)''
|-
| style="text-align:center;" | '''Array=(element1 element2element3)''' || ''Инициализация массива''
|-
| style="text-align:center;" | '''result=$(COMMAND)''' || ''Команда исполняется в подоболочке, результат записывается в переменную''
|-
| style="text-align:center;" | '''>(COMMAND)''' || ''Подстановка процесса''
|-
| style="text-align:center;" | '''<(COMMAND)''' || ''Подстановка процесса''
|-
| style="text-align:center;" | <div style="color:blue">'''Двойные круглые скобки''' </div>||
|-
| style="text-align:center;" | '''(( var = 78 ))''' || ''Целочисленная арифметика''
|-
| style="text-align:center;" | '''var=$(( 20 + 5 ))''' || ''Арифметическое выражение, результат записывается в переменную''
|-
| style="text-align:center;" | <div style="color:blue">'''Кавычки''' <div>||
|-
| style="text-align:center;" | '''"$variable"''' || ''"Мягкие", или "нестрогие" кавычки''
|-
| style="text-align:center;" | ''' 'string' ''' || ''"Строгие", или "полные" кавычки''
|-
| style="text-align:center;" | <div style="color:blue">'''Обратные кавычки''' </div>||
|-
| style="text-align:center;" | '''result=`COMMAND`''' || ''Команда исполняется в подоболочке, результат записывается в переменную''
|}

 '''Таблица B-7. Выражения, используемые в инструкции if'''
{| class="wikitable" style="margin-left: auto; margin-right: auto;
|-
! '''''Первичное выражение''''' !! '''''Значение''''' !! '''''Первичное выражение''''' !! '''''Значение'''''
|-
| style="text-align:center;" | '''[ -a FILE ]''' || Истина, если FILE существует. || style="text-align:center;" | '''[ -b FILE ]''' || Истина, если FILE существует и является блочным файлом.
|-
| style="text-align:center;" | '''[ -c FILE ]''' || Истина, если FILE существует и является строковым файлом. || style="text-align:center;" | '''[ -d FILE ]''' || Истина, если FILE существует и является директорией.
|-
| style="text-align:center;" | '''[ -e FILE ]''' || Истина, если FILE существует. || style="text-align:center;" | '''[ -f FILE ]''' || Истина, если FILE существует и является обычным файлом.
|-
| style="text-align:center;" | '''[ -g FILE ]''' || Истина, если FILE существует и у него установлен бит SGID. || style="text-align:center;" | '''[ -h FILE ]''' || Истина, если FILE существует и является символической ссылкой.
|-
| style="text-align:center;" | '''[ -k FILE ]''' || Истина, если FILE существует и у него установлен промежуточный бит округления. || style="text-align:center;" | '''[ -p FILE ]''' || Истина, если FILE существует и является именованным конвейером (FIFO).
|-
| style="text-align:center;" | '''[ -r FILE ]''' || Истина, если FILE существует и доступен для чтения. || style="text-align:center;" | '''[ -s FILE ]''' || Истина, если FILE существует и его размер больше нуля.
|-
| style="text-align:center;" | '''[ -t FD ]''' || Истина, если дескриптор файла FD открыт и ссылается на терминал. || style="text-align:center;" | '''[ -u FILE ]''' || Истина, если FILE существует и у него установлен бит SUID (установлен идентификатор пользователя ID)
|-
| style="text-align:center;" | '''[ -w FILE ]''' || Истина, если FILE существует и доступен для записи. || style="text-align:center;" | '''[ -x FILE ]''' || Истина, если FILE существует и является исполняемым.
|-
| style="text-align:center;" | '''[ -O FILE ]''' || Истина, если FILE существует и его владельцем является действующий пользователь. || style="text-align:center;" | '''[ -G FILE ]''' || Истина, если FILE существует и его владелец принадлежит к действующей группе.
|-
| style="text-align:center;" | '''[ -L FILE ]''' || Истина, если FILE существует и является символической ссылкой. || style="text-align:center;" | '''[ -N FILE ]''' || Истина, если FILE существует и был модифицирован после последнего чтения.
|-
| style="text-align:center;" | '''[ -S FILE ]''' || Истина, если FILE существует и является сокетом. || style="text-align:center;" | '''[ FILE1 -nt FILE2 ]''' || Истина, если FILE1 был изменен раньше, чем FILE2, либо если FILE1 существует, а FILE2 не существует.
|-
| style="text-align:center;" | '''[ FILE1 -ot FILE2 ]''' || Истина, если FILE1 изменен позже, чем FILE2, либо если FILE2 существует, а FILE1 не существует. || style="text-align:center;" | '''[ FILE1 -ef FILE2 ]''' || Истина, если FILE1 и FILE2 ссылаются на одно и то же устройство или на одинаковые номера inode.
|-
| style="text-align:center;" | '''[ -o OPTIONNAME ]''' || Истина, если установлен параметр командной оболочки "OPTIONNAME". || style="text-align:center;" | '''[ -z "STRING" ]''' || Истина, если длина строки "STRING" равна нулю.
|-
| style="text-align:center;" | '''[ -n "STRING" ]''' или '''[ "STRING" ]''' || Истина, если длина строки "STRING" ненулевая. || style="text-align:center;" | '''[ "STRING1" == "STRING2" ]''' || Истина, если строки равны. Для более строгого соответствия POSIX вместо "==" можно использовать "=".
|-
| style="text-align:center;" | '''[ "STRING1" != "STRING2" ]''' || Истина, если строки не равны || style="text-align:center;" | '''[ "STRING1" < "STRING2" ]''' || Истина, если в текущей локали при лексикографической сортировке "STRING1" оказывается перед "STRING2".
|-
| style="text-align:center;" width="15%"| '''[ "STRING1" > "STRING2" ]''' || Истина, если в текущей локали при лексикографической сортировке "STRING1" оказывается после "STRING2". || style="text-align:center;" | '''[ ARG1 OP ARG2 ]''' || "OP" — один из операторов -eq, -ne, -lt, -le, -gt или -ge(см. Таблица B-2. Операции проверки: Двухместные операции)."ARG1" и "ARG2" являются целыми числами.
|-
| style="text-align:center;" | '''[ ! EXPR ]''' || Истина, если EXPR ложно. || style="text-align:center;" width="15%"| '''[ ( EXPR ) ]''' || Возвращает значение EXPR. Используется для изменения нормального предшествования операторов.
|-
| style="text-align:center;" | '''[ EXPR1 -a EXPR2 ]''' || Истина, если оба EXPR1 и EXPR2 являются истинными. || style="text-align:center;" | '''[ EXPR1 -o EXPR2 ]''' || Истина, если либо EXPR1, либо EXPR2 истинно.
|-
|}

= Приложение C. Маленький учебник по Sed и Awk =
В этом приложении содержится очень краткое описание приемов работы с утилитами обработки текста [[sed]] и [[awk]]. Здесь будут рассмотрены лишь несколько базовых команд, которых, в принципе, будет достаточно, чтобы научиться понимать простейшие конструкции [[sed]] и [[awk]] внутри сценариев на языке командной оболочки. 
'''[[sed]]''': неинтерактивный редактор текстовых файлов 
'''[[awk]]''': язык обработки шаблонов с C-подобным синтаксисом 
При всех своих различиях, эти две утилиты обладают похожим синтаксисом, они обе умеют работать с регулярными выражениями, обе, по-умолчанию, читают данные с устройства ''stdin'' и обе выводят результат обработки на устройство ''stdout''. Обе являются утилитами Unix-систем, и прекрасно могут взаимодействовать между собой. Вывод от одной может быть перенаправлен, по конвейеру, на вход другой. Их комбинирование придаёт сценариям, на языке командной оболочки, мощь и гибкость языка '''''Perl'''''. 
Одно важное отличие состоит в том, что в случае с [[sed]], сценарий легко может передавать дополнительные аргументы этой утилите, в то время, как в случае с [[awk]] это более сложная задача.
== C 1. Sed ==
'''Sed''' — это неинтерактивный строчный редактор. Он принимает текст либо с устройства ''stdin'', либо из текстового файла, выполняет некоторые операции над строками и затем выводит результат на устройство ''stdout'' или в файл. Как правило, в сценариях, [[sed]] используется в конвейерной обработке данных, совместно с другими командами и утилитами. Sed определяет, по заданному адресному пространству, над какими строками следует выполнить операции. Адресное пространство строк задаётся либо их порядковыми номерами, либо шаблоном. Например, команда ''3d'' заставит [[sed]] удалить третью строку, а команда ''/windows/d'' означает, что все строки, содержащие "''windows''", должны быть удалены. Из всего разнообразия операций, мы остановимся на трёх, используемых наиболее часто. Это ''p'' — печать (на ''stdout''), ''d'' — удаление и ''s'' — замена.
 '''Таблица C-1. Основные операции sed'''
{| class="wikitable" style="margin-left: 365px; margin-right: 0px;"
|-
! '''''Операция''''' !! '''''Название''''' !! '''''Описание'''''
|-
| style="text-align:center;" | '''[диапазон строк]/p''' || ''print'' || ''Печать [указанного диапазона строк]''
|-
| style="text-align:center;" | '''[диапазон строк]/d''' || ''delete'' || ''Удалить [указанный диапазон строк]''
|-
| style="text-align:center;" | '''s/pattern1/pattern2/''' || ''substitute'' || ''Заменить первое встреченное соответствие''
''шаблону pattern1, в строке, на pattern2''
|-
| style="text-align:center;" | '''[диапазон строк]/s/pattern1/pattern2/''' || ''substitute'' || ''Заменить первое встреченное соответствие шаблону''
''pattern1, на pattern2, в указанном диапазоне строк''
|-
| style="text-align:center;" | '''[диапазон строк]/y/pattern1/pattern2/''' || ''transform'' || ''заменить любые символы из шаблона pattern1 на соответствующие символы''
''из pattern2, в указанном диапазоне строк(эквивалент команды tr)''
|-
| style="text-align:center;" | '''g''' || ''global'' || ''Операция выполняется над всеми найденными соответствиями''
''внутри каждой из заданных строк''
|} 
Без оператора ''g'' (''global''), операция замены будет производиться только для первого найденного совпадения, с заданным шаблоном, в каждой строке. 
В отдельных случаях, операции [[sed]] необходимо заключать в кавычки. 

<source lang="bash">
sed -e '/^$/d' $filename
# Ключ -e говорит о том, что далее следует строка, которая должна интерпретироваться
# как набор инструкций редактирования.
# (При передаче одной инструкции, ключ "-e" является необязательным.)
# "Строгие" кавычки ('') предотвращают интерпретацию символов регулярного выражения,
# как специальных символов, командным интерпретатором.
#
# Действия производятся над строками, содержащимися в файле $filename.
</source> 
В отдельных случаях, команды редактирования не работают в одиночных кавычках. 
<source lang="bash">
filename=file1.txt
pattern=BEGIN

sed "/^$pattern/d" "$filename" # Результат вполне предсказуем.
# sed '/^$pattern/d' "$filename" даёт иной результат.
# В данном случае, в "строгих" кавычках (' ... '),
# не происходит подстановки значения переменной "$pattern".
</source> 
Sed использует ключ ''-e'' для того, чтобы определить, что следующая строка является инструкцией, или набором инструкций, редактирования. Если инструкция является единственной, то использование этого ключа не является обязательным. 
<source lang="bash">
sed -n '/xzy/p' $filename
# Ключ -n заставляет sed вывести только те строки, которые совпадают с указанным шаблоном.
# В противном случае (без ключа -n), будут выведены все строки.
# Здесь, ключ -e не является обязательным, поскольку здесь стоит единственная команда.
</source> 
 '''Таблица C-2. Примеры операций в sed'''
{| class="wikitable" style="margin-left: 365px; margin-right: 0px;"
|-
! '''''Операция''''' !! '''''Описание'''''
|-
| style="text-align:center;" | '''8d''' || ''Удалить 8-ю строку''.
|-
| style="text-align:center;" | '''/^$/d''' || ''Удалить все пустые строки''.
|-
| style="text-align:center;" | '''1,/^$/d''' || ''Удалить все строки до первой пустой строки, включительно''.
|-
| style="text-align:center;" | '''/Jones/p''' || ''Вывести строки, содержащие "Jones"(с ключом -n)''.
|-
| style="text-align:center;" | '''s/Windows/Linux/''' || ''В каждой строке, заменить первое встретившееся слово "Windows" на слово "Linux"''.
|-
| style="text-align:center;" | '''s/BSOD/stability/g''' || ''В каждой строке, заменить все встретившиеся слова "BSOD" на "stability"''.
|-
| style="text-align:center;" | '''s/ *$//''' || ''Удалить все пробелы в конце каждой строки''.
|-
| style="text-align:center;" | '''s/00*/0/g''' || ''Заменить все последовательности ведущих нулей одним символом "0"''.
|-
| style="text-align:center;" | '''/GUI/d''' || ''Удалить все строки, содержащие "GUI"''.
|-
| style="text-align:center;" | '''s/GUI//g''' || ''Удалить все найденные "GUI", оставляя остальную часть строки без изменений''.
|}
 

Замена строки пустой строкой, эквивалентна удалению части строки, совпадающей с шаблоном. Остальная часть строки остается без изменений. Например, ''s/GUI//'', изменит следующую строку 
''The most important parts of any application are its GUI and sound effects'' 
на 
''The most important parts of any application are its and sound effects'' 
Символ обратного слэша представляет символ перевода строки, как символ замены. В этом случае, замещающее выражение продолжается на следующей строке. 
<source lang="bash">
s/^ */\
/g
</source> 
Эта инструкция заменит начальные пробелы в строке на символ перевода строки. Ожидаемый результат — замена отступов в начале параграфа пустыми строками. 
Указание диапазона строк, предшествующее одной, или более, инструкции может потребовать заключения инструкций в фигурные скобки, с соответствующими символами перевода строки. 
<source lang="bash">
/[0-9A-Za-z]/,/^$/{
/^$/d
}
</source> 
В этом случае будут удалены только первые из нескольких, идущих подряд, пустых строк. Это может использоваться для установки однострочных интервалов в файле, оставляя, при этом, пустые строки между параграфами. 
Быстрый способ установки двойных межстрочных интервалов в текстовых файлах — <source lang="bash">sed G filename</source> .
Ссылки на дополнительные сведения о [[sed]], вы найдёте в разделе Библиография данной книги.
== C 2. Awk ==
'''''Awk''''' — это полноценный язык обработки текстовой информации с синтаксисом, напоминающим синтаксис языка ''C''. Он обладает довольно широким набором возможностей, однако, мы рассмотрим лишь некоторые из них — наиболее употребимые в сценариях командной оболочки. '''''Awk''''' "разбивает" каждую строку на отдельные поля. По-умолчанию, поля — это последовательности символов, отделённые друг от друга пробелами, однако имеется возможность назначения других символов, в качестве разделителя полей. '''''Awk''''' анализирует и обрабатывает каждое поле в отдельности. Это делает его идеальным инструментом для работы со структурированными текстовыми файлами — особенно с таблицами. 
Внутри сценариев командной оболочки, код [[awk]], заключается в "строгие" (одиночные) кавычки и фигурные скобки.
<source lang="bash">
awk '{print $3}' $filename
# Выводит содержимое 3-го поля из файла $filename на устройство stdout.

awk '{print $1 $5 $6}' $filename
# Выводит содержимое 1-го, 5-го и 6-го полей из файла $filename.
</source> 
Только что, мы рассмотрели действие команды ''print''. Ещё, на чём мы остановимся — это переменные. '''''Awk''''' работает с переменными подобно сценариям командной оболочки, но более гибко. 
<source lang="bash">
{ total += ${column_number} }
</source> 
Эта команда добавит содержимое переменной ''column_number'' к переменной ''total''. Чтобы, в завершение вывести ''total'', можно использовать команду '''END''', которая открывает блок кода, отрабатывающий после того, как будут обработаны все входные данные.
<source lang="bash">
END { print total }
</source> 
Команде '''END''', соответствует команда '''BEGIN''', которая открывает блок кода, отрабатывающий перед началом обработки входных данных. Следующий пример демонстрирует применение [[awk]] для разбора текста в сценариях командной оболочки. 
 '''Пример''': '''''C-1. Подсчёт количества символов.'''''
<source lang="bash">
#! /bin/sh
# letter-count.sh: Counting letter occurrences in a text file.
#
# Автор: nyal (nyal@voila.fr).
# Используется с разрешения автора сценария.
# Комментарии добавлены автором документа.

INIT_TAB_AWK=""

count_case=0
FILE_PARSE=$1
E_PARAMERR=65

usage()
{
echo "Порядок использования: letter-count.sh имя_файла символы" 2>&1
# Например: ./letter-count.sh filename.txt a b c
exit $E_PARAMERR # Вызов сценария без аргументов.
}

if [ ! -f "$1" ] ; then
echo "Файл $1 не найден." 2>&1
usage # Вывод сообщения и выход.
fi

if [ -z "$2" ] ; then
echo "$2: Не заданы символы для поиска." 2>&1
usage
fi

shift # Символы заданы.
for letter in `echo $@` # Для каждого из них . . .
do
INIT_TAB_AWK="$INIT_TAB_AWK tab_search[${count_case}] = \"$letter\"; final_tab[${count_case}] = 0;"
# Передаётся как параметр в сценарий awk ниже.
count_case=`expr $count_case + 1`
done

# DEBUG:
# echo $INIT_TAB_AWK;
cat $FILE_PARSE |
# Передать заданный файл по конвейеру в сценарий awk.

# --------------------------------------------------------------------------------
# От переводчика:
# В оригинальном тексте сценария стоит следующая строка:
#awk -v tab_search=0 -v final_tab=0 -v tab=0 -v nb_letter=0 -v chara=0 -v chara2=0 \
#
# с моим gawk 3.1.3 сценарий делается неработоспособным
# поэтому я взял на себя смелость несколько подправить эту строку,
# в результате она получилась такой:
awk -v nb_letter=0 -v chara=0 -v chara2=0 \
"BEGIN { $INIT_TAB_AWK } \
{ split(\$0, tab, \"\"); \
for (chara in tab) \
{ for (chara2 in tab_search) \
{ if (tab_search[chara2] == tab[chara]) { final_tab[chara2]++ } } } } \
END { for (chara in final_tab) \
{ print tab_search[chara] \" => \" final_tab[chara] } }"
# --------------------------------------------------------------------------------
# Ничего сложного...
# Циклы for, проверка условия if, и пара специфических функций.

exit $?
</source> 
Это всё, что я хотел рассказать об [[awk]]. Дополнительные ссылки на информацию об [[awk]], вы найдёте в разделе Библиография.

= Приложение D. Коды завершения, имеющие предопределённый смысл =
 '''Таблица D-1. "Зарезервированные" коды завершения'''
{| class="wikitable" style="margin-left: 180px; margin-right: 100px;"
|-
! Код завершения !! Смысл !! Пример !! Примечание
|-
| style="text-align:center;" | '''1''' || ''Разнообразные ошибки'' || ''let "var1= 1/0" '' || ''Различные ошибки, такие как "деление на ноль" и пр. ''
|-
| style="text-align:center;" | '''2''' || ''Согласно документации к Bash'' — ''неверное использование встроенных команд'' || || ''Встречаются довольно редко, обычно код завершения возвращается равным 1''
|-
| style="text-align:center;" | '''126''' || ''Вызываемая команда не может быть выполнена'' || || ''Возникает из-за проблем с правами доступа'' ''или когда вызван на исполнение неисполняемый файл''
|-
| style="text-align:center;" | '''127''' || ''"Команда не найдена"'' || || ''Проблема связана либо с переменной окружения $PATH, либо с неверным написанием имени команды''
|-
| style="text-align:center;" | '''128''' || ''Неверный аргумент команды exit'' || ''exit 3.14159'' || ''Команда exit может принимать только целочисленные значения, в диапазоне 0-255''
|-
| style="text-align:center;" | '''128+n''' || ''Фатальная ошибка по сигналу "n"'' || ''kill -9 $PPID сценария'' || ''$? вернёт 137 (128 + 9)''
|-
| style="text-align:center;" | '''130''' || ''Завершение по Control-C'' || || ''"Control-C" это выход по сигналу 2, (130 =128 + 2, см.выше)''
|-
| style="text-align:center;" | '''255''' || ''Код завершения вне допустимого диапазона || ''exit -1'' || ''exit может принимать только целочисленные значения, в диапазоне 0-255''
|}
Согласно этой таблице, коды завершения '''1'''-'''2''', '''126'''-'''165''' и '''255''' имеют предопределённое значение, поэтому вам следует избегать употребления этих кодов для своих нужд. Завершение сценария с кодом возврата ''exit 127'', может привести в замешательство при поиске ошибок в сценарии (действительно ли он означает ошибку "команда не найдена"? Или это предусмотренный программистом код завершения?). В большинстве случаев, программисты вставляют ''exit 1'', в качестве реакции на ошибку. Так как код завершения '''1''' подразумевает целый "букет" ошибок, то в данном случае трудно говорить о какой-либо двусмысленности, хотя и об информативности — тоже. 
Не раз предпринимались попытки систематизировать коды завершения (см. /usr/include/sysexits.h), но эта систематизация предназначена для программистов, пишущих на языках ''C'' и ''C++''. Автор документа предлагает ограничить коды завершения, определяемые пользователем, диапазоном '''64'''-'''113''' (и, само собой разумеется — '''0''', для обозначения успешного завершения), в соответствии со стандартом ''C/C++''. Это сделало бы поиск ошибок более простым. Все сценарии, прилагаемые к данному документу, приведены в соответствие с этим стандартом, за исключением случаев, когда существуют отменяющие обстоятельства. 
<big>'''!'''</big>Обращение к переменной '''$?''', из командной строки, после завершения работы сценария, даёт результат, в соответствии с таблицей, приведенной выше, но только для Bash или sh. Под управлением csh или tcsh значения могут в некоторых случаях отличаться.

= Приложение E. Подробное введение в операции ввода-вывода и перенаправление ввода-вывода =
:::''Написано Stephane Chazelas и дополнено автором документа''. 
Практически любая команда предполагает доступность 3-х файловых дескрипторов. Первый — '''0'''(стандартный ввод, ''stdin''), доступный для чтения. И два других — ''1'' (стандартный вывод, ''stdout'') и '''2''' (поток ошибок, ''stderr''), доступные для записи. 
Запись, типа '''ls 2>&1''', означает временное перенаправление вывода, с устройства ''stderr'' на устройство ''stdout''. В соответствии с соглашениями, команды принимают ввод из файла с дескриптором '''0''' (''stdin''), выводят результат работы в файл с дескриптором '''1''' ('''stdout'''), а сообщения об ошибках — в файл с дескриптором '''2''' (''stderr''). Если какой-либо из этих трёх дескрипторов окажется закрытым, то могут возникнуть определенные проблемы: 
<source lang="bash">
bash$ cat /etc/passwd >&-
cat: standard output: Bad file descriptor
</source> 
К примеру, когда пользователь запускает '''xterm''', то он сначала выполняет процедуру инициализации, а затем, перед запуском командной оболочки, '''xterm''' трижды открывает терминальные устройства (/dev/pts/<n>, или нечто подобное). После этого, командная оболочка наследует эти три дескриптора, и любая команда, запускаемая в этой оболочке, так же наследует их. Термин перенаправление — означает переназначение одного файлового дескриптора на другой (канал(конвейер) или что-то другое). Переназначение может быть выполнено локально (для отдельной команды, для группы команд, для подоболочки, для операторов ''while'', ''if'', ''case'', ''for''...) или глобально (с помощью '''exec'''). 
<source lang="bash">
ls > /dev/null
</source> 
Команда выше означает запуск команды [[ls]] с файловым дескриптором '''1''', присоединённым к устройству ''/dev/null''.
<source lang="bash">
bash$ lsof -a -p $$ -d0,1,2
COMMAND PID USER FD TYPE DEVICE SIZE NODE NAME
bash 363 bozo 0u CHR 136,1 3 /dev/pts/1
bash 363 bozo 1u CHR 136,1 3 /dev/pts/1
bash 363 bozo 2u CHR 136,1 3 /dev/pts/1

bash$ exec 2> /dev/null
bash$ lsof -a -p $$ -d0,1,2
COMMAND PID USER FD TYPE DEVICE SIZE NODE NAME
bash 371 bozo 0u CHR 136,1 3 /dev/pts/1
bash 371 bozo 1u CHR 136,1 3 /dev/pts/1
bash 371 bozo 2w CHR 1,3 120 /dev/null

bash$ bash -c 'lsof -a -p $$ -d0,1,2' | cat
COMMAND PID USER FD TYPE DEVICE SIZE NODE NAME
lsof 379 root 0u CHR 136,1 3 /dev/pts/1
lsof 379 root 1w FIFO 0,0 7118 pipe
lsof 379 root 2u CHR 136,1 3 /dev/pts/1

bash$ echo "$(bash -c 'lsof -a -p $$ -d0,1,2' 2>&1)"
COMMAND PID USER FD TYPE DEVICE SIZE NODE NAME
lsof 426 root 0u CHR 136,1 3 /dev/pts/1
lsof 426 root 1w FIFO 0,0 7520 pipe
lsof 426 root 2w FIFO 0,0 7520 pipe
</source> 
Упражнение: Проанализируйте следующий сценарий.
<source lang="bash">
#! /usr/bin/env bash

mkfifo /tmp/fifo1 /tmp/fifo2

while read a; do echo "FIFO1: $a"; done < /tmp/fifo1 &
exec 7> /tmp/fifo1
exec 8> >(while read a; do echo "FD8: $a, to fd7"; done >&7)

exec 3>&1(
(
(
( while read a; do echo "FIFO2: $a"; done < /tmp/fifo2 | tee /dev/stderr | tee /dev/fd/4 | tee /dev/fd/5 | tee /dev/fd/6 >&7 & exec 3> /tmp/fifo2
echo 1st, to stdout
sleep 1
echo 2nd, to stderr >&2
sleep 1
echo 3rd, to fd 3 >&3
sleep 1
echo 4th, to fd 4 >&4
sleep 1
echo 5th, to fd 5 >&5
sleep 1
echo 6th, through a pipe | sed 's/.*/PIPE: &, to fd 5/' >&5
sleep 1
echo 7th, to fd 6 >&6
sleep 1
echo 8th, to fd 7 >&7
sleep 1
echo 9th, to fd 8 >&8
) 4>&1 >&3 3>&- | while read a; do echo "FD4: $a"; done 1>&3 5>&- 6>&-
) 5>&1 >&3 | while read a; do echo "FD5: $a"; done 1>&3 6>&-
) 6>&1 >&3 | while read a; do echo "FD6: $a"; done 3>&-

rm -f /tmp/fifo1 /tmp/fifo2
# Выясните, куда переназначены файловые дескрипторы каждой команды и подоболочки.

exit 0
</source> 

= Приложение F. Системные каталоги =
Системный администратор, да и любой другой, кто занимается созданием сценариев для обслуживания системы должен чётко знать о существовании следующих системных каталогов. 
* <big>'''/bin'''</big> 
:Каталог с программами. В этом каталоге размещаются основные системные программы и утилиты (например '''bash''').
* <big>'''/usr/bin'''</big> 
:Дополнительные системные каталоги.
* <big>'''/usr/local/bin'''</big> 
:Программы разного рода.
* <big>'''/sbin'''</big> 
:''Superuser binaries'' — программы суперпользователя. Основные программы и утилиты административного назначения (например '''fsck''').
* <big>'''/usr/sbin'''</big> 
:Дополнительные программы суперпользователя.
* <big>'''/etc'''</big> 
:''Et cetera''. Конфигурационные системные скрипты.
* <big>'''/etc/rc.d'''</big> 
:Сценарии начальной загрузки системы, для дистрибутива Red Hat и его клонов.
* <big>'''/usr/share/doc'''</big> 
:Документация к установленным пакетам.
* <big>'''/tmp'''</big> 
:Временный каталог системы.
* <big>'''/var/log'''</big> 
:Каталог для хранения системных журналов (логов).
* <big>'''/var/spool/mail'''</big> 
:Буфер для электронной почты.

= Приложение G. Локализация =
Возможность локализации сценариев Bash нигде в документации не описана. 
Локализованные сценарии выводят текст на том языке, который используется системой, в соответствии с настройками. Пользователь Linux, живущий в Берлине(Германия), будет видеть сообщения на немецком языке, в то время как другой пользователь, проживающий в Берлине штата Мэриленд (США) — на английском. 
Для создания локализованных сценариев можно использовать следующий шаблон, предусматривающий вывод всех сообщений на языке пользователя (сообщения об ошибках, приглашения к вводу и т.п.).
<source lang="bash">
#!/bin/bash
# localized.sh
# Автор Stephane Chazelas, дополнил Bruno Haible

. gettext.sh

E_CDERROR=65

error()
{
printf "$@" >&2
exit $E_CDERROR
}

cd $var || error "`eval_gettext \"Can't cd to \$var.\"`"
read -p "`gettext \"Enter the value: \"`" var
# ...
</source> 
<source lang="bash">
bash$ bash -D localized.sh
"Can't cd to %s."
"Enter the value: "
</source> 
Это список всех текстовых сообщений, которые подлежат локализации(Ключ ''-D'' выводит список строк в двойных кавычках, которым предшествует символ '''$''', без запуска сценария на исполнение).
<source lang="bash">
bash$ bash --dump-po-strings localized.sh
#: a:6
msgid "Can't cd to %s."
msgstr ""
#: a:7
msgid "Enter the value: "
msgstr ""
</source> 
Ключ ''--dump-po-strings'' в Bash напоминает ключ ''-D'', но выводит строки в формате "po", с помощью утилиты '''gettext'''. 
<big>'''!'''</big>''Bruno Haible'' отмечает, что: 
:Начиная с версии '''gettext-0.12.2''', вместо '''bash --dump-po-strings localized.sh''', рекомендуется использовать '''xgettext -o - localized.sh''', потому что '''xgettext'''...
::'''1'''. понимает команды '''gettext''' и '''eval_gettext''' (тогда как '''bash --dump-po-strings''' только свой синтаксис в виде $"..." )
::'''2'''. может извлекать комментарии программиста, предназначенные для переводчика. 
Такой код не привязан к определенной версии Bash и может быть исполнен в Bash 1.x или других реализациях /bin/sh. 
Теперь построим файл ''language.po'', для каждого языка, на которые предполагается перевести сообщения сценария. Например: 
Файл ''ru.po'' сделан переводчиком, в оригинальном документе локализация выполнена на примере французского языка. 
:'''ru.po''':
<source lang="bash">
#: a:6
msgid "Can't cd to %s."
msgstr "Невозможно перейти в каталог %s."
#: a:7
msgid "Enter the value: "
msgstr "Введите число: "
</source> 
Затем запустите '''msgfmt'''. 
<source lang="bash">msgfmt -o localized.sh.mo ru.po</source> 
Перепишите получившийся файл '''localized.sh.mo''' в каталог ''/usr/share/locale/ru/LC_MESSAGES'' и добавьте в начало сценария строки:
<source lang="bash">
TEXTDOMAINDIR=/usr/share/locale
TEXTDOMAIN=localized.sh
</source> 
Если система корректно настроена на русскую локаль, то пользователь, запустивший сценарий, будет видеть сообщения на русском языке.

<big>'''!'''</big> В старых версиях Bash или в других командных оболочках, потребуется воспользоваться услугами утилиты '''gettext''', с ключом ''-s''. В этом случае наш сценарий будет выглядеть так: 
<source lang="bash">
#!/bin/bash
# localized.sh

E_CDERROR=65
error() {
local format=$1
shift
printf "$(gettext -s "$format")" "$@" >&2
exit $E_CDERROR
}
cd $var || error "Can't cd to %s." "$var"
read -p "$(gettext -s "Enter the value: ")" var
# ...
</source> 
А переменные ''TEXTDOMAIN'' и ''TEXTDOMAINDIR'', необходимо будет экспортировать в окружение. 
Это приложение написано ''Stephane Chazelas'', и дополнено ''Bruno Haible'', ведущим разработчиком GNU '''gettext'''.

= Приложение H. История команд =
Командная оболочка Bash предоставляет в распоряжение пользователя инструментарий командной строки, позволяющий управлять ''историей'' команд. История команд — это, прежде всего, очень удобный инструмент, сокращающий ручной ввод. 
:История команд Bash: 
:# '''history'''
:# '''fc'''
<source lang="bash">
bash$ history
1 mount /mnt/cdrom
2 cd /mnt/cdrom
3 ls
...
</source> 
''Внутренние переменные Bash'', связанные с историей команд: 
:# '''$HISTCMD'''
:# '''$HISTCONTROL'''
:# '''$HISTIGNORE'''
:# '''$HISTFILESIZE'''
:# '''$HISTSIZE'''
:# '''!!'''
:# '''!$'''
:# '''!#'''
:# '''!N'''
:# '''!-N'''
:# '''!STRING'''
:# '''!?STRING?'''
:# '''^STRING^string^'''
К сожалению, инструменты истории команд, в Bash, совершенно бесполезны в сценариях! 
<source lang="bash">
#!/bin/bash
# history.sh
# Попытка воспользоваться 'историей' команд в сценарии.

history
# На экран ничего не выводится.
# История команд не работает в сценариях.
</source> 
<source lang="bash">
bash$ ./history.sh
(ничего не выводится)
</source> 

= Приложение I. Пример файла .bashrc =
Файл ''~/.bashrc'' определяет поведение командной оболочки. Внимательное изучение этого примера поможет вам значительно продвинуться в понимании Bash. Emmanuel Rouat представил следующий, очень сложный, файл ''.bashrc'', написанный для операционной системы Linux. Предложения и замечания приветствуются. 
Внимательно изучите этот файл. Отдельные участки этого файла вы свободно можете использовать в своём собственном ''.bashrc'' или, даже в своих сценариях!
 '''Пример I-1. Пример файла .bashrc'''
<source lang="bash">
#===============================================================
#
# ЛИЧНЫЙ ФАЙЛ $HOME/.bashrc для bash-2.05a (или выше)
#
# Время последней модификации: Втр Апр 15 20:32:34 CEST 2003
#
# Этот файл содержит настройки интерактивной командной оболочки.
# Здесь размещены определения псевдонимов, функций
# и других элементов Bash, таких как prompt (приглашение к вводу).
#
# Изначально, этот файл был создан в операционной системе Solaris,
# но позднее был переделан под Redhat
# --> Модифицирован под Linux.
# Большая часть кода, который находится здесь, была взята из
# Usenet (или Интернет).
# Этот файл содержит слишком много определений — помните, это всего лишь пример.
#
#
#===============================================================

# --> Комментарии, добавленные автором HOWTO.
# --> И дополнены автором сценария Emmanuel Rouat :-)

#-----------------------------------
# Глобальные определения
#-----------------------------------

if [ -f /etc/bashrc ]; then
. /etc/bashrc # --> Прочитать настройки из /etc/bashrc, если таковой имеется.
fi

#-------------------------------------------------------------
# Настройка переменной $DISPLAY (если еще не установлена)
# Это срабатывает под linux - в вашем случае все может быть по другому....
# Проблема в том, что различные типы терминалов
# дают разные ответы на запрос 'who am i'......
# я не нашёл 'универсального' метода
#-------------------------------------------------------------

function get_xserver ()
{
case $TERM in
xterm )
XSERVER=$(who am i | awk '{print $NF}' | tr -d ')''(' )
XSERVER=${XSERVER%%:*}
;;
aterm | rxvt)
# добавьте здесь свой код.....
;;
esac
}

if [ -z ${DISPLAY:=""} ]; then
get_xserver
if [[ -z ${XSERVER} || ${XSERVER} == $(hostname) || ${XSERVER} == "unix" ]]; then
DISPLAY=":0.0" # для локального хоста
else
DISPLAY=${XSERVER}:0.0 # для удалённого хоста
fi
fi

export DISPLAY

#---------------
# Некоторые настройки
#---------------

ulimit -S -c 0 # Запрет на создание файлов coredump
set -o notify
set -o noclobber
set -o ignoreeof
set -o nounset
#set -o xtrace # полезно для отладки

# Разрешающие настройки:
shopt -s cdspell
shopt -s cdable_vars
shopt -s checkhash
shopt -s checkwinsize
shopt -s mailwarn
shopt -s sourcepath
shopt -s no_empty_cmd_completion # только для bash>=2.04
shopt -s cmdhist
shopt -s histappend histreedit histverify
shopt -s extglob

# Запрещающие настройки:
shopt -u mailwarn
unset MAILCHECK # Я не желаю, чтобы командная оболочка сообщала мне о прибытии почты

export TIMEFORMAT=$'\nreal %3R\tuser %3U\tsys %3S\tpcpu %P\n'
export HISTIGNORE="&:bg:fg:ll:h"
export HOSTFILE=$HOME/.hosts
# Поместить список удаленных хостов в файл ~/.hosts

#-----------------------
# Greeting, motd etc...
#-----------------------

# Для начала определить некоторые цвета:
red='\e[0;31m'
RED='\e[1;31m'
blue='\e[0;34m'
BLUE='\e[1;34m'
cyan='\e[0;36m'
CYAN='\e[1;36m'
NC='\e[0m' # No Color (нет цвета)
# --> Прекрасно. Имеет тот же эффект, что и "ansi.sys" в DOS.

# Лучше выглядит на черном фоне.....
echo -e "${CYAN}This is BASH ${RED}${BASH_VERSION%.*}${CYAN} - DISPLAY on ${RED}$DISPLAY${NC}\n"
date
if [ -x /usr/games/fortune ]; then
/usr/games/fortune -s # сделает наш день более интересным.... :-)
fi

function _exit() # функция, запускающаяся при выходе из оболочки
{
echo -e "${RED}Аста ла виста, бэби ${NC}"
}
trap _exit EXIT

#---------------
# Prompt
#---------------

if [[ "${DISPLAY#$HOST}" != ":0.0" && "${DISPLAY}" != ":0" ]]; then
HILIT=${red} # на удаленной системе: prompt будет частично красным
else
HILIT=${cyan} # на локальной системе: prompt будет частично циановым
fi
# --> Замените \W на \w в функциях ниже
# --> чтобы видеть в оболочке полный путь к текущему каталогу.

function fastprompt()
{
unset PROMPT_COMMAND
case $TERM in
*term | rxvt )
PS1="${HILIT}[\h]$NC \W > \[\033]0;\${TERM} [\u@\h] \w\007\]" ;;
linux )
PS1="${HILIT}[\h]$NC \W > " ;;
*)
PS1="[\h] \W > " ;;
esac
}

function powerprompt()
{
_powerprompt()
{
LOAD=$(uptime|sed -e "s/.*: $[^,]*$.*/\1/" -e "s/ //g")
}

PROMPT_COMMAND=_powerprompt
case $TERM in
*term | rxvt )
PS1="${HILIT}[\A \$LOAD]$NC\n[\h \#] \W > \[\033]0;\${TERM} [\u@\h] \w\007\]" ;;
linux )
PS1="${HILIT}[\A - \$LOAD]$NC\n[\h \#] \w > " ;;
* )
PS1="[\A - \$LOAD]\n[\h \#] \w > " ;;
esac
}

powerprompt # это prompt по-умолчанию - может работать довольно медленно
# Если это так, то используйте fastprompt....

#===============================================================
#
# ПСЕВДОНИМЫ И ФУНКЦИИ
#
# Возможно некоторые из функций, приведенных здесь, окажутся для вас слишком большими,
# но на моей рабочей станции установлено 512Mb ОЗУ, так что.....
# Если пожелаете уменьшить размер этого файла, то можете оформить эти функции
# в виде отдельных сценариев.
#
# Большинство функций были взяты, почти без переделки, из примеров
# к bash-2.04.
#
#===============================================================

#-------------------
# Псевдонимы
#-------------------

alias rm='rm -i'
alias cp='cp -i'
alias mv='mv -i'
# -> Предотвращает случайное удаление файлов.

alias mkdir='mkdir -p'
alias h='history'
alias j='jobs -l'
alias r='rlogin'
alias which='type -all'
alias ..='cd ..'
alias path='echo -e ${PATH//:/\\n}'
alias print='/usr/bin/lp -o nobanner -d $LPDEST' # Предполагается, что LPDEST определён
alias pjet='enscript -h -G -fCourier9 -d $LPDEST' # Печать через enscript
alias background='xv -root -quit -max -rmode 5' # Положить картинку в качестве фона
alias du='du -kh'
alias df='df -kTh'

# Различные варианты 'ls' (предполагается, что установлена GNU-версия ls)
alias la='ls -Al' # показать скрытые файлы
alias ls='ls -hF --color' # выделить различные типы файлов цветом
alias lx='ls -lXB' # сортировка по расширению
alias lk='ls -lSr' # сортировка по размеру
alias lc='ls -lcr' # сортировка по времени изменения
alias lu='ls -lur' # сортировка по времени последнего обращения
alias lr='ls -lR' # рекурсивный обход подкаталогов
alias lt='ls -ltr' # сортировка по дате
alias lm='ls -al |more' # вывод через 'more'
alias tree='tree -Csu' # альтернатива 'ls'

# подготовка 'less'
alias more='less'
export PAGER=less
export LESSCHARSET='latin1'
export LESSOPEN='|/usr/bin/lesspipe.sh %s 2>&-' # если существует lesspipe.sh
export LESS='-i -N -w -z-4 -g -e -M -X -F -R -P%t?f%f \
:stdin .?pb%pb\%:?lbLine %lb:?bbByte %bb:-...'

# проверка правописания - настоятельно рекомендую :-)
alias xs='cd'
alias vf='cd'
alias moer='more'
alias moew='more'
alias kk='ll'

#----------------
# добавим немножко "приятностей"
#----------------

function xtitle ()
{
case "$TERM" in
*term | rxvt)
echo -n -e "\033]0;$*\007" ;;
*)
;;
esac
}

# псевдонимы...
alias top='xtitle Processes on $HOST && top'
alias make='xtitle Making $(basename $PWD) ; make'
alias ncftp="xtitle ncFTP ; ncftp"

# .. и функции
function man ()
{
for i ; do
xtitle The $(basename $1|tr -d .[:digit:]) manual
command man -F -a "$i"
done
}

function ll(){ ls -l "$@"| egrep "^d" ; ls -lXB "$@" 2>&-| egrep -v "^d|total "; }
function te() # "обертка" вокруг xemacs/gnuserv
{
if [ "$(gnuclient -batch -eval t 2>&-)" == "t" ]; then
gnuclient -q "$@";
else
( xemacs "$@" &);
fi
}

#-----------------------------------
# Функции для работы с файлами и строками:
#-----------------------------------

# Поиск файла по шаблону:
function ff() { find . -type f -iname '*'$*'*' -ls ; }
# Поиск файла по шаблону в $1 и запуск команды в $2 с ним:
function fe() { find . -type f -iname '*'$1'*' -exec "${2:-file}" {} \; ; }
# поиск строки по файлам:

function fstr()
{
OPTIND=1
local case=""
local usage="fstr: поиск строки в файлах.
Порядок использования: fstr [-i] \"шаблон\" [\"шаблон_имени_файла\"] "
while getopts :it opt
do
case "$opt" in
i) case="-i " ;;
*) echo "$usage"; return;;
esac
done
shift $(( $OPTIND - 1 ))
if [ "$#" -lt 1 ]; then
echo "$usage"
return;
fi
local SMSO=$(tput smso)
local RMSO=$(tput rmso)
find . -type f -name "${2:-*}" -print0 | xargs -0 grep -sn ${case} "$1" 2>&- | \
sed "s/$1/${SMSO}\0${RMSO}/gI" | more
}

function cuttail() # удалить последние n строк в файле, по-умолчанию 10
{
nlines=${2:-10}
sed -n -e :a -e "1,${nlines}!{P;N;D;};N;ba" $1
}

function lowercase() # перевести имя файла в нижний регистр
{
for file ; do
filename=${file##*/}
case "$filename" in
*/*) dirname==${file%/*} ;;
*) dirname=.;;
esac
nf=$(echo $filename | tr A-Z a-z)
newname="${dirname}/${nf}"
if [ "$nf" != "$filename" ]; then
mv "$file" "$newname"
echo "lowercase: $file --> $newname"
else
echo "lowercase: имя файла $file не было изменено."
fi
done
}

function swap() # меняет 2 файла местами
{
local TMPFILE=tmp.$$
mv "$1" $TMPFILE
mv "$2" "$1"
mv $TMPFILE "$2"
}

#-----------------------------------
# Функции для работы с процессами/системой:
#-----------------------------------

function my_ps() { ps $@ -u $USER -o pid,%cpu,%mem,bsdtime,command ; }
function pp() { my_ps f | awk '!/awk/ && $0~var' var=${1:-".*"} ; }

# Эта функция является грубым аналогом 'killall' в linux
# но не эквивалентна (насколько я знаю) 'killall' в Solaris
function killps() # "Прибить" процесс по его имени
{
local pid pname sig="-TERM" # сигнал, рассылаемый по-умолчанию
if [ "$#" -lt 1 ] || [ "$#" -gt 2 ]; then
echo "Порядок использования: killps [-SIGNAL] шаблон_имени_процесса"
return;
fi

if [ $# = 2 ]; then sig=$1 ; fi
for pid in $(my_ps| awk '!/awk/ && $0~pat { print $1 }' pat=${!#} ) ; do
pname=$(my_ps | awk '$1~var { print $5 }' var=$pid )
if ask "Послать сигнал $sig процессу $pid <$pname>?"
then kill $sig $pid
fi
done
}

function my_ip() # IP адрес
{
MY_IP=$(/sbin/ifconfig ppp0 | awk '/inet/ { print $2 } ' | sed -e s/addr://)
MY_ISP=$(/sbin/ifconfig ppp0 | awk '/P-t-P/ { print $3 } ' | sed -e s/P-t-P://)
}

function ii() # Дополнительные сведения о системе
{
echo -e "\nВы находитесь на ${RED}$HOST"
echo -e "\nДополнительная информация:$NC " ; uname -a
echo -e "\n${RED}В системе работают пользователи:$NC " ; w -h
echo -e "\n${RED}Дата:$NC " ; date
echo -e "\n${RED}Время, прошедшее с момента последней перезагрузки :$NC " ; uptime
echo -e "\n${RED}Память :$NC " ; free
my_ip 2>&- ;
echo -e "\n${RED}IP адрес:$NC" ; echo ${MY_IP:-"Соединение не установлено"}
echo -e "\n${RED}Адрес провайдера (ISP):$NC" ; echo ${MY_ISP:-"Соединение не установлено"}
echo
}

# Разные утилиты:
function repeat() # повторить команду n раз
{
local i max
max=$1; shift;
for ((i=1; i <= max ; i++)); do # --> C-подобный синтаксис
eval "$@";
done
}

function ask()
{
echo -n "$@" '[y/n] ' ; read ans
case "$ans" in
y*|Y*) return 0 ;;
*) return 1 ;;
esac
}

#=========================================================================
#
# ПРОГРАММНЫЕ ДОПОЛНЕНИЯ - ТОЛЬКО НАЧИНАЯ С ВЕРСИИ BASH-2.04
# Большая часть дополнений взята из документации к bash 2.05 и из
# пакета 'Bash completion' (http://www.caliban.org/bash/index.shtml#completion)
# автор — Ian McDonalds# Фактически, у вас должен стоять bash-2.05a
#
#=========================================================================

if [ "${BASH_VERSION%.*}" \< "2.05" ]; then
echo "Вам необходимо обновиться до версии 2.05"
return
fi
shopt -s extglob # необходимо
set +o nounset # иначе некоторые дополнения не будут работать
complete -A hostname rsh rcp telnet rlogin r ftp ping disk
complete -A export printenv
complete -A variable export local readonly unset
complete -A enabled builtin
complete -A alias alias unalias
complete -A function function
complete -A user su mail finger

complete -A helptopic help
complete -A shopt shopt
complete -A stopped -P '%' bg
complete -A job -P '%' fg jobs disown

complete -A directory mkdir rmdir
complete -A directory -o default cd

# Архивация
complete -f -o default -X '*.+(zip|ZIP)' zip
complete -f -o default -X '!*.+(zip|ZIP)' unzip
complete -f -o default -X '*.+(z|Z)' compress
complete -f -o default -X '!*.+(z|Z)' uncompress
complete -f -o default -X '*.+(gz|GZ)' gzip
complete -f -o default -X '!*.+(gz|GZ)' gunzip
complete -f -o default -X '*.+(bz2|BZ2)' bzip2
complete -f -o default -X '!*.+(bz2|BZ2)' bunzip2
# Postscript,pdf,dvi.....
complete -f -o default -X '!*.ps' gs ghostview ps2pdf ps2ascii
complete -f -o default -X '!*.dvi' dvips dvipdf xdvi dviselect dvitype
complete -f -o default -X '!*.pdf' acroread pdf2ps
complete -f -o default -X '!*.+(pdf|ps)' gv
complete -f -o default -X '!*.texi*' makeinfo texi2dvi texi2html texi2pdf
complete -f -o default -X '!*.tex' tex latex slitex
complete -f -o default -X '!*.lyx' lyx
complete -f -o default -X '!*.+(htm*|HTM*)' lynx html2ps# Multimedia
complete -f -o default -X '!*.+(jp*g|gif|xpm|png|bmp)' xv gimp
complete -f -o default -X '!*.+(mp3|MP3)' mpg123 mpg321
complete -f -o default -X '!*.+(ogg|OGG)' ogg123

complete -f -o default -X '!*.pl' perl perl5

# Эти 'универсальные' дополнения работают тогда, когда команды вызываются
# с, так называемыми, 'длинными ключами', например: 'ls --all' вместо 'ls -a'

_get_longopts ()
{
$1 --help | sed -e '/--/!d' -e 's/.*--$[^[:space:].,]*$.*/--\1/'| \
grep ^"$2" |sort -u ;
}

_longopts_func ()
{
case "${2:-*}" in
-*) ;;
*) return ;;
esac

case "$1" in
\~*) eval cmd="$1" ;;
*) cmd="$1" ;;
esac
COMPREPLY=( $(_get_longopts ${1} ${2} ) )
}
complete -o default -F _longopts_func configure bash
complete -o default -F _longopts_func wget id info a2ps ls recode

_make_targets ()
{
local mdef makef gcmd cur prev i

COMPREPLY=()
cur=${COMP_WORDS[COMP_CWORD]}
prev=${COMP_WORDS[COMP_CWORD-1]}

# Если аргумент prev это -f, то вернуть возможные варианты имен файлов.
# будем великодушны и вернем несколько вариантов
# `makefile Makefile *.mk'
case "$prev" in
-*f) COMPREPLY=( $(compgen -f $cur ) ); return 0;;
esac

# Если запрошены возможные ключи, то вернуть ключи posix
case "$cur" in
-) COMPREPLY=(-e -f -i -k -n -p -q -r -S -s -t); return 0;;
esac

# попробовать передать make `makefile' перед тем как попробовать передать `Makefile'
if [ -f makefile ]; then
mdef=makefile
elif [ -f Makefile ]; then
mdef=Makefile
else
mdef=*.mk
fi

# прежде чем просмотреть "цели", убедиться, что имя makefile было задано
# ключом -f
for (( i=0; i < ${#COMP_WORDS[@]}; i++ )); do
if [[ ${COMP_WORDS[i]} == -*f ]]; then
eval makef=${COMP_WORDS[i+1]}
break
fi
done

[ -z "$makef" ] && makef=$mdef
# Если задан шаблон поиска, то ограничиться
# этим шаблоном
if [ -n "$2" ]; then gcmd='grep "^$2"' ; else gcmd=cat ; fi
# если мы не желаем использовать *.mk, то необходимо убрать cat и использовать
# test -f $makef с перенаправлением ввода
COMPREPLY=( $(cat $makef 2>/dev/null | awk 'BEGIN {FS=":"} /^[^.# ][^=]*:/ {print $1}' | tr -s ' ' '\012' | sort -u | eval $gcmd ) )
}

complete -F _make_targets -X '+($*|*.[cho])' make gmake pmake
# cvs(1) completion_cvs ()
_cvs ()
{
local cur prev
COMPREPLY=()
cur=${COMP_WORDS[COMP_CWORD]}
prev=${COMP_WORDS[COMP_CWORD-1]}

if [ $COMP_CWORD -eq 1 ] || [ "${prev:0:1}" = "-" ]; then
COMPREPLY=( $( compgen -W 'add admin checkout commit diff \
export history import log rdiff release remove rtag status \
tag update' $cur ))
else
COMPREPLY=( $( compgen -f $cur ))
fi
return 0
}

complete -F _cvs cvs

_killall ()
{
local cur prev
COMPREPLY=()
cur=${COMP_WORDS[COMP_CWORD]}

# получить список процессов
COMPREPLY=( $( /usr/bin/ps -u $USER -o comm | \
sed -e '1,1d' -e 's#[]\[]##g' -e 's#^.*/##'| \
awk '{if ($0 ~ /^'$cur'/) print $0}' ))
return 0
}

complete -F _killall killall killps
# Функция обработки мета-команд
# В настоящее время недостаточно отказоустойчива (например, mount и umount
# обрабатываются некорректно), но все еще актуальна. Автор Ian McDonald, изменена мной.

_my_command()
{
local cur func cline cspec

COMPREPLY=()
cur=${COMP_WORDS[COMP_CWORD]}

if [ $COMP_CWORD = 1 ]; then
COMPREPLY=( $( compgen -c $cur ) )
elif complete -p ${COMP_WORDS[1]} &>/dev/null; then
cspec=$( complete -p ${COMP_WORDS[1]} )
if [ "${cspec%%-F *}" != "${cspec}" ]; then
# complete -F <function>
#
# COMP_CWORD and COMP_WORDS() доступны на запись,
# так что мы можем установить их перед тем,
# как передать их дальше

# уменьшить на 1 текущий номер лексемы
COMP_CWORD=$(( $COMP_CWORD - 1 ))
# получить имя функции
func=${cspec#*-F }
func=${func%% *}
# получить командную строку, исключив первую команду
cline="${COMP_LINE#$1 }"
# разбить на лексемы и поместить в массив
COMP_WORDS=( $cline )
$func $cline
elif [ "${cspec#*-[abcdefgjkvu]}" != "" ]; then
# complete -[abcdefgjkvu]
#func=$( echo $cspec | sed -e 's/^.*$-[abcdefgjkvu]$.*$/\1/' )
func=$( echo $cspec | sed -e 's/^complete//' -e 's/[^ ]*$//' )
COMPREPLY=( $( eval compgen $func $cur ) )
elif [ "${cspec#*-A}" != "$cspec" ]; then
# complete -A <type>
func=${cspec#*-A }
func=${func%% *}
COMPREPLY=( $( compgen -A $func $cur ) )
fi
else
COMPREPLY=( $( compgen -f $cur ) )
fi
}

complete -o default -F _my_command nohup exec eval trace truss strace sotruss gdb
complete -o default -F _my_command command type which man nice

# Локальные переменные:
# mode:shell-script
# sh-shell:bash
# Конец:
</source> 

= Приложение J. Преобразование пакетных (*.bat) файлов DOS в сценарии командной оболочки =
Большое число программистов начинало изучать скриптовые языки на PC, работающих под управлением ''DOS''. Даже на этом "калеке" удавалось создавать неплохие сценарии, хотя это и требовало значительных усилий. Иногда ещё возникает потребность в переносе пакетных файлов ''DOS'' на платформу ''Unix'', в виде сценариев командной оболочки. Обычно это не сложно, поскольку набор операторов, доступных в ''DOS'', представляет из себя ограниченное подмножество эквивалентных команд, доступных в командной оболочке.
 '''Таблица J-1. Ключевые слова/переменные/операторы пакетных файлов DOS и их аналоги командной оболочки'''
{| class="wikitable" style="margin-left: 365px; margin-right: 0px;"
|-
! Операторы пакетных файлов !! Эквивалентные команды в Unix !! Описание
|-
| '''%''' || '''&''' || ''Префикс аргументов командной строки''
|-
| '''/''' || '''-''' || ''Признак ключа(опции)''
|-
| '''\''' || '''/''' || ''Разделитель имен каталогов в пути''
|-
| '''==''' || '''=''' || ''(Равно)сравнение строк''
|-
| '''!==!''' || '''!=''' || ''(Не равно) сравнение строк
|-
| '''|''' || '''|''' || ''конвейер(канал)''
|-
| '''@''' || '''set +v''' || ''Не выводить текущую команду''
|-
| '''*''' || '''*''' || ''"Шаблонный символ" в имени файла''
|-
| '''>''' || '''>''' || ''Перенаправление(с удалением существующего файла)
|-
| '''>>''' || '''>>''' || ''Перенаправление(с добавлением в конец существующего файла)
|-
| '''<''' || '''<''' || ''Перенаправление ввода stdin''
|-
| '''%VAR%''' || '''$VAR''' || ''Переменная окружения''
|-
| '''REM''' || '''#''' || ''Комментарий''
|-
| '''NOT''' || '''!''' || ''Отрицание последующего условия''
|-
| '''NUL''' || '''/dev/null''' || ''"Чёрная дыра" для того, чтобы "спрятать" вывод команды
|-
| '''ECHO''' || '''echo''' || ''Вывод(в Bash имеет большое число опций)
|-
| '''ECHO.''' || '''echo''' || ''Вывод пустой строки''
|-
| '''ECHO OFF''' || '''set +v''' || ''Не выводить последующие команды''
|-
| '''FOR %%VAR IN (LIST) DO''' || '''for var in [list]; do''' || ''Цикл "for"''
|-
| ''':LABEL''' || '''Эквивалент отсутствует (нет необходимости) || ''Метка''
|-
| '''GOTO''' || '''Эквивалент отсутствует (используйте функции) || ''Переход по заданной метке''
|-
| '''PAUSE''' || '''sleep''' || ''Пауза, или ожидание, в течение заданного времени''
|-
| '''CHOICE''' || '''case''' или '''select''' || ''Выбор из меню''
|-
| '''IF''' || '''if''' || ''Условный оператор if''
|-
| '''IF EXIST FILENAME''' || '''if [ -e filename ]''' || ''Проверка существования файла''
|-
| '''IF !%N==!''' || '''if [ -z "$N" ]''' || ''Проверка: параметр "N" отсутствует''
|-
| '''CALL''' || '''source''' или <big>'''.'''</big>(оператор "точка") || ''"Подключение" другого сценария''
|-
| '''COMMAND /C''' || '''source''' или <big>'''.'''</big>(оператор "точка") || ''"Подключение" другого сценария (то же, что и CALL)
|-
| '''SET''' || '''export''' || ''Установить переменную окружения''
|-
| '''SHIFT''' || '''shift''' || ''Cдвиг списка аргументов командной строки влево''
|-
| '''SGN''' || '''-lt''' или '''-gt''' || ''Знак (целого числа)''
|-
| '''ERRORLEVEL''' || '''$?''' || ''Код завершения''
|-
| '''CON''' || '''stdin''' || ''"Консоль" (stdin)''
|-
| '''PRN''' || '''/dev/lp0''' || ''Устройство принтера''
|-
| '''LPT1''' || '''/dev/lp0''' || ''Устройство принтера''
|-
| '''COM1''' || '''/dev/ttyS0''' || ''Первый последовательный порт''
|-
|}
Пакетные файлы обычно содержат вызовы команд ''DOS''. Они должны быть заменены эквивалентными командами Unix.
 '''Таблица J-2. Команды DOS и их эквиваленты в Unix'''
{| class="wikitable" style="margin-left: 385px; margin-right: 0px;"
|-
! '''''Команды DOS''''' !! '''''Эквивалент в Unix''''' !! '''''Описание'''''
|-
| '''ASSIGN''' || '''ln''' || ''Ссылка на файл или каталог''
|-
| '''ATTRIB''' || '''chmod''' || ''изменить атрибуты файла (права доступа)''
|-
| '''CD''' || '''cd''' || ''Сменить каталог''
|-
| '''CHDIR''' || '''cd''' || ''Сменить каталог''
|-
| '''CLS''' || '''clear''' || ''Очистить экран''
|-
| '''COMP''' || '''diff, comm, cmp''' || ''Сравнить файлы''
|-
| '''COPY''' || '''cp''' || ''Скопировать файл''
|-
| '''Ctl-C''' || '''Ctl-C''' || ''Прервать исполнение сценария''
|-
| '''Ctl-Z''' || '''Ctl-D''' || ''EOF (конец файла)''
|-
| '''DEL''' || '''rm''' || ''Удалить файл(ы)''
|-
| '''DELTREE''' || '''rm -rf''' || ''Удалить каталог с подкаталогами''
|-
| '''DIR''' || '''ls -l''' || ''Вывести содержимое каталога''
|-
| '''ERASE''' || '''rm''' || ''Удалить файл(ы)''
|-
| '''EXIT''' || '''exit''' || ''Завершить текущий процесс''
|-
| '''FC''' || '''comm, cmp''' || ''Сравнить файлы''
|-
| '''FIND''' || '''grep''' || ''Найти строку в файлах''
|-
| '''MD''' || '''mkdir''' || ''Создать каталог''
|-
| '''MKDIR''' || '''mkdir''' || ''Создать каталог''
|-
| '''MORE''' || '''more''' || ''Постраничный вывод''
|-
| '''MOVE''' || '''mv''' || ''Переместить''
|-
| '''PATH''' || '''$PATH''' || ''Путь поиска исполняемых файлов''
|-
| '''REN''' || '''mv''' || ''Переименовать (переместить)''
|-
| '''RENAME''' || '''mv''' || ''Переименовать (переместить)''
|-
| '''RD''' || '''rmdir''' || ''Удалить каталог''
|-
| '''RMDIR''' || '''rmdir''' || ''Удалить каталог''
|-
| '''SORT''' || '''sort''' || ''Отсортировать файл''
|-
| '''TIME''' || '''date''' || ''Вывести системное время''
|-
| '''TYPE''' || '''cat''' || ''вывести содержимое файла на stdout''
|-
| '''XCOPY''' || '''cp''' || ''Скопировать файл(расширенная команда)''
|}
<big>'''!'''</big>Фактически, команды и операторы командной оболочки Unix имеют огромное количество дополнительных опций, расширяющих их функциональность, по сравнению с их эквивалентами в ''DOS''. В большинстве своём, пакетные файлы ''DOS'' предполагают наличие вспомогательных утилит, таких как '''ask.com''' ("увечный" аналог Unix-вого '''''read'''''). 
''DOS'' поддерживает крайне ограниченный набор шаблонных символов, участвующих в операциях подстановки имён файлов, распознавая только два символа — <big>'''*'''</big> и <big>'''?'''</big>. 
Преобразование пакетных файлов ''DOS'' в сценарии командной оболочки, обычно не вызывает затруднений, а результат такого преобразования читается гораздо лучше, чем оригинал.
 '''Пример''': '''''Пример J-1. VIEWDATA.BAT: пакетный файл DOS'''''
<source lang="dos">
REM VIEWDATA

REM INSPIRED BY AN EXAMPLE IN "DOS POWERTOOLS"
REM BY PAUL SOMERSON

@ECHO OFF

IF !%1==! GOTO VIEWDATA
REM IF NO COMMAND-LINE ARG...

FIND "%1" C:\BOZO\BOOKLIST.TXT
GOTO EXIT0
REM PRINT LINE WITH STRING MATCH, THEN EXIT.

:VIEWDATA
TYPE C:\BOZO\BOOKLIST.TXT | MORE
REM SHOW ENTIRE FILE, 1 PAGE AT A TIME.

:EXIT0
</source> 
Результат преобразования в сценарий командной оболочки, немного улучшенный.
 '''Пример''': '''''Пример J-2. viewdata.sh: Результат преобразования VIEWDATA.BAT в сценарий командной оболочки'''''
<source lang="bash">
#!/bin/bash
# Результат преобразования пакетного файла VIEWDATA.BAT в сценарий командной оболочки.

DATAFILE=/home/bozo/datafiles/book-collection.data
ARGNO=1

# @ECHO OFF Эта команда здесь не нужна.

if [ $# -lt "$ARGNO" ] # IF !%1==! GOTO VIEWDATA
then
less $DATAFILE # TYPE C:\MYDIR\BOOKLIST.TXT | MORE
else
grep "$1" $DATAFILE # FIND "%1" C:\MYDIR\BOOKLIST.TXT
fi

exit 0 # :EXIT0

# Операторы перехода GOTO, метки и прочий "мусор" больше не нужны.
# Результат преобразования стал короче, чище и понятнее.
</source> 
На сайте ''Тэда Дэвиса''(''Ted Davis'') [http://www.maem.umr.edu/~batch/ Shell Scripts on the PC], вы найдёте большое число руководств по созданию пакетных файлов в ''DOS''. Определённо, его изобретательность будет вам полезна, при создании ваших сценариев.

= Приложение K. Упражнения =
== K1. Анализ сценариев ==
Просмотрите следующие сценарии. Попробуйте запустить их, затем объясните — что они делают. Расставьте комментарии и попробуйте записать сценарии в более компактном виде.
<source lang="bash">
#!/bin/bash

MAX=10000

for((nr=1; nr<$MAX; nr++))
do
let "t1 = nr % 5"
if [ "$t1" -ne 3 ]
then
continue
fi

let "t2 = nr % 7"
if [ "$t2" -ne 4 ]
then
continue
fi

let "t3 = nr % 9"
if [ "$t3" -ne 5 ]
then
continue
fi

break # Что произойдёт, если закомментировать эту строку? Почему?
done

echo "Число = $nr"

exit 0
</source> 
Читатель прислал следующий кусок кода: 
<source lang="bash">
while read LINE
do
echo $LINE
done < `tail -f /var/log/messages`
</source> 
Он предполагал написать сценарий, который отслеживал бы изменения в системном журнале ''/var/log/messages''. К сожалению, этот код "зависает" и не делает ничего полезного. Почему? Найдите ошибку и исправьте её (подсказка: вместо операции перенаправления stdin в цикл, попробуйте использовать конвейерную обработку). 
Просмотрите сценарий Пример A-11, попробуйте изменить его таким образом, чтобы он выглядел проще и логичнее. Удалите всё "лишние" переменные и попытайтесь оптимизировать сценарий по скорости исполнения. Измените сценарий таким образом, чтобы он мог принимать начальную установку "поколения 0" из любого текстового файла. Сценарий должен считать первые $ROW*$COL символов, и на место гласных вставлять "живые особи". Подсказка: не забудьте преобразовать пробелы в символы подчеркивания.

== K2. Создание сценариев ==
Напишите сценарии для выполнения повседневных задач. 
 
<big>'''Простые задания'''</big> 
'''Содержимое домашнего каталога'''
:Выполните рекурсивный обход домашнего каталога и сохраните информацию в файл. Сожмите файл. Попросите пользователя вставить дискету и нажать клавишу ''ENTER''. Запишите сжатый файл на дискету.
'''Замена цикла for циклами while и until'''
:Замените циклы ''for'' в '''Пример''': '''''Простой цикл for''''' (из главы ''Циклы и ветвления'') на ''while''. Подсказка: запишите данные в массив и пройдите в цикле по элементам массива. 
:Выполнив эту "тяжёлую работу", замените циклы, в этом примере, на циклы ''until''.
'''Изменение межстрочного интервала в текстовом файле'''
:Напишите сценарий, который будет читать текст из заданного файла, и выводить, построчно, на ''stdout'', добавляя при этом дополнительные пустые строки так, чтобы в результате получился вывод с двойным ''межстрочным интервалом''. 
:Добавьте код, который будет выполнять проверку наличия файла, передаваемого как аргумент. 
:Когда сценарий будет отлажен, измените его так, чтобы он выводил текстовый файл с тройным ''межстрочным интервалом''. 
:И наконец, напишите сценарий, который будет удалять пустые строки из заданного файла.
'''Вывод "задом-на-перёд"'''
:Напишите сценарий, который будет выводить себя на ''stdout'', но в обратном порядке.
'''Автоматическое разархивирование'''
:Для каждого файла, из заданного списка, сценарий должен определить тип архиватора, которым был создан тот или иной файл (с помощью утилиты '''file'''). Затем сценарий должен выполнить соответствующую команду разархивации ('''gunzip''', '''bunzip2''', '''unzip''', '''uncompress''' или что-то иное). Если файл не является архивом, то сценарий должен оповестить пользователя об этом и ничего не делать с этим файлом.
'''Уникальный идентификатор системы'''
:Сценарий должен сгенерировать "уникальный" 6-ти разрядный шестнадцатиричный идентификатор системы. Не пользуйтесь дефектной утилитой '''hostid''. Подсказка: '''md5sum /etc/passwd''', затем отберите первые 6 цифр.
'''Резервное копирование'''
:Сценарий должен создать архив (*.tar.gz) всех файлов в домашнем каталоге пользователя(/home/user-name), которые изменялись в течение последних 24 часов. Подсказка: воспользуйтесь утилитой '''find'''.
'''Простые числа'''
:Сценарий должен вывести (на ''stdout'') все простые числа, в диапазоне от 60000 до 63000. Вывод должен быть отформатирован по столбцам (подсказка: воспользуйтесь командой '''printf''').
'''Лототрон'''
:Сценарий должен имитировать работу лототрона — извлекать 5 случайных неповторяющихся чисел в диапазоне 1-50. Сценарий должен предусматривать как вывод на ''stdout'', так и запись чисел в файл, кроме того, вместе с числами должны выводиться дата и время генерации данного набора.
 
<big>'''Задания повышенной сложности'''</big> 
'''Управление дисковым пространством'''
:Сценарий должен отыскать в домашнем каталоге пользователя ''/home/username'' файлы, имеющие размер больше 100K. Каждый раз предоставляя пользователю возможность удалить или сжать этот файл, затем переходить к поиску следующего файла.
'''Безопасное удаление'''
:Напишите сценарий "безопасного" удаления файлов — srm.sh. Файлы, с именами, передаваемыми этому сценарию, не должны удаляться, вместо этого, файлы следует сжать утилитой [[gzip]], если они ещё не сжаты (не забывайте про утилиту '''file'''), и переместить в каталог ''/home/username/trash''. При старте, сценарий должен удалять из каталога "trash" файлы, которые были созданы более 48 часов тому назад.
'''Размен монет'''
:Как более рационально собрать сумму в $1.68, используя только монеты, с номиналом не выше 25c? Это будет шесть 25-ти центовых монет, одна десятицентовая, одна пятицентовая и три монеты достоинством в 1 цент. 
:Учитывая возможность произвольного ввода суммы в долларах и центах ($*.??), найдите такую комбинацию, которая требовала бы наименьшее число монет. Если вы проживаете не в США, то можете использовать свою денежную единицу и номиналы монет. Подсказка: взгляните на '''Пример''': '''''Преобразование чисел в римскую форму записи'''''.
'''Корни квадратного уравнения'''
:Напишите сценарий, который находил бы корни "квадратного " уравнения, вида: ''Ax^2+Bx+C=0''. Сценарий должен получать коэффициенты уравнения A, B и C, как аргументы командной строки, и находить корни, с точностью до четвёртого знака после запятой. 
:Подсказка: воспользуйтесь '''bc''', для нахождения решения по хорошо известной формуле: ''x = ( -B+/- sqrt( B^2 - 4AC ) ) / 2A''.
'''Сумма чисел'''
:Найдите сумму всех пятизначных чисел (в диапазоне 10000-99999), которые содержат точно две цифры из следующего набора: {4, 5, 6}. 
:Примеры чисел, удовлетворяющих данному условию: 42057, 74638 и 89515.
'''Счастливый билет'''
:"Счастливым" считается такой билет, в котором последовательное сложение цифр номера даёт число 7. Например, 62431 — номер "счастливого" билета (6+2+4+3+1=16, 1+6 = 7). Найдите все "счастливые" номера, располагающиеся в диапазоне 1000-10000.
'''Синтаксический анализ'''
:Проанализируйте файл ''/etc/passwd'' и выведите его содержимое в табличном виде.
'''Контроль входов в систему'''
:Проанализируйте файл ''/var/log/messages'' и выведите в отформатированном виде сведения по каждому пользователю — когда он входил в систему. Возможно, что для работы сценарию потребуются права root. (Подсказка: Ищите строки, содержащие текст "LOGIN")
'''Просмотр файла с данными'''
:Некоторые базы данных и электронные таблицы используют формат CSV (''comma-separated values'' — значения, разделённые запятыми), для хранения данных в файлах. Зачастую, эти файлы должны анализироваться другими приложениями. 
:Пусть файл содержит следующие данные: 
:''Jones,Bill,235 S. Williams St.,Denver,CO,80221,(303) 244-7989 Smith,Tom,404 Polk Ave.,Los Angeles,CA,90003,(213) 879-5612...''
:Прочитайте данные и выведите их на ''stdout'' в виде колонок с заголовками.
'''Выравнивание'''
:Текст вводится с устройства ''stdin'' или из файла. Его необходимо вывести на ''stdout'', с выравниванием по ширине, используя задаваемую пользователем ширину строк.
'''Список рассылки'''
:Напишите сценарий, который использовал бы команду '''mail''', для управления простым списком рассылки. Сценарий должен брать текст ежемесячного информационного бюллетеня из заданного файла, список адресатов из другого файла и выполнять рассылку новостей по электронной почте.
'''Генерация паролей'''
:Сгенерируйте псевдослучайные 8-ми символьные пароли, используя символы из диапазона [0-9], [A-Z], [a-z]. Каждый пароль должен содержать не менее 2-х цифр.
 
<big>'''Сложные задания'''</big> 
'''Проверка паролей'''
:Напишите сценарий проверки простоты раскрытия заданного пароля. 
:Исследуемый пароль должен передаваться сценарию как аргумент командной строки. Пароль должен отвечать следующим минимальным требованиям: 
:* Минимальная длина — 8 символов
:* Должен содержать хотя бы одну цифру
:* Должен содержать хотя бы один из следующих символов: @, #, $, %, &, *, +, -, =
:''Необязательно'':
:*Проверка возможности подбора по словарю каждой последовательной четвёрки алфавитных символов. Это исключит вхождение "словарных словwords" в пароль.
:*Проверьте с помощью этого сценария все пароли в вашей системе, которые могут располагаться в ''/etc/passwd'' (или в другом месте).
:Для создания такого сценария вам потребуется умение работать с ''регулярными выражениями''.
'''Регистрация обращений к файлам'''
:Попробуйте отследить все попытки обращения к файлам в каталоге ''/etc'', в течение дня. Сведения, которые включают в себя время обращения, имя файла, имя пользователя (если имели место какие-либо изменения в файлах, то они тоже должны быть отмечены), запишите в виде аккуратно отформатированных записей в лог-файл.
'''Мониторинг процессов'''
:Напишите сценарий, который производит непрерывный мониторинг запускаемых процессов и отслеживает количество дочерних процессов для каждого "родителя". Как только процесс порождает более 5 дочерних процессов, сценарий должен послать уведомление системному администратору (или root-у) с соответствующей информацией. В письме необходимо указать время, PID "родителя", PID каждого "потомка" и пр.. Сценарий должен писать отчет в системный журнал один раз в 10 минут.
'''Удаление комментариев'''
:Удалите все комментарии из сценария, имя которого задается с командной строки. При этом, строка "''#! /bin/bash''" не должна удаляться.
'''Преобразование в HTML'''
Преобразуйте заданный текстовый файл в HTML формат. Этот сценарий должен автоматически вставлять необходимые теги HTML в тело файла.
'''Удаление тегов HTML'''
:Удалите все теги HTML из заданного HTML файла, затем переформатируйте его так, чтобы строки не были короче 60 и длиннее 75 символов. Предусмотрите оформление параграфов. Преобразуйте таблицы HTML в их приблизительный текстовый эквивалент.
'''Преобразование XML файлов'''
:Преобразуйте файл из формата XML в формат HTML и в простой текстовый файл.
'''Борьба со спамом'''
:Напишите сценарий, который анализировал бы входящие почтовые сообщения на принадлежность к спаму и отыскивал бы в DNS имена узлов сети, по IP адресам из заголовка письма. Сценарий должен отправлять найденные спамерские сообщения ответственным за спам-провайдерам (ISP). Естественно, вы должны отфильтровать свой собственный IP-адрес, чтобы не случилось так, что вы жалуетесь на самого себя. 
:По мере необходимости, используйте соответствующие команды для работы с сетью.
'''Азбука Морзе'''
:Преобразуйте текстовый файл в код Морзе. Символы из файла должны быть представлены в виде, соответствующих им, кодов Морзе, состоящих из точек и тире, и разделённых пробелами. Например, "'''script'''" ===> "'''... _._. ._. .. .__. _'''".
'''Шестнадцатиричный дамп'''
:Выведите, в виде шестнадцатиричного дампа, содержимое бинарного файла, передаваемого в сценарий, как аргумент командной строки. Вывод должен производиться в четкой табличной форме, первое поле таблицы — адрес, далее должны следовать 8 полей, содержащие 4-хбайтовые шестнадцатиричные числа, а завершать строку должно поле, содержащее эквивалентное отображение 8-ми предшествующих полей, в виде ASCII-символов.
'''Эмуляция сдвигового регистра'''
:Используя '''Пример''': '''''Эмуляция структуры "СТЕК" ("первый вошёл — последний вышел")''''', как образец, напишите сценарий, который эмулировал бы 64-х битный сдвиговый регистр в виде массива. Реализуйте функции загрузки значения в регистр, сдвиг влево и сдвиг вправо. В заключение, напишите функцию, которая интерпретировала бы содержимое "регистра" как восемь 8-ми битных символов ''ASCII''.
'''Детерминант (определитель)'''
:Найдите детерминант (определитель) матрицы 4x4.
'''Анаграммы'''
:Сценарий должен запросить у пользователя 4-х символьное слово, и найти анаграммы для этого слова. Например, анаграммы к слову word: do or rod row word. Для поиска анаграмм можете использовать файл ''/usr/share/dict/linux.words''.
'''Индекс сложности текста'''
:"Индекс сложности текста" оценивает трудность понимания текста, как некое число, которое грубо соответствует количеству лет обучения в общеобразовательной школе. Например, индекс равный 8-ми говорит о том, что текст доступен для понимания человеку, окончившему 8-й класс общеобразовательной школы. 
:Вычисление индекса ведется по следующему алгоритму:
:# Выберите кусок текста, длиной не менее 100 слов.
:# Сосчитайте количество предложений.
:# Найдите среднее число слов в предложении — '''СРЕДНЕЕ_ЧИСЛО_СЛОВ'''=''ОБЩЕЕ_ЧИСЛО_СЛОВ/ЧИСЛО_ПРЕДЛОЖЕНИЙ''
:# Сосчитайте количество "трудных" слов — которые содержат не менее 3-х слогов. Разделите это число на общее количество слов, в результате вы получите пропорцию сложных слов — '''ПРОПОРЦИЯ_СЛОЖНЫХ_СЛОВ'''=''ЧИСЛО_ДЛИННЫХ_СЛОВ/ОБЩЕЕ_ЧИСЛО_СЛОВ''
:# Индекс сложности текста рассчитывается как сумма двух этих чисел, умноженная на 0.4 и округлённая до ближайшего целого — '''ИНДЕКС_СЛОЖНОСТИ'''=''int (0.4*( СРЕДНЕЕ_ЧИСЛО_СЛОВ +ПРОПОРЦИЯ_СЛОЖНЫХ_СЛОВ))'' 
:4-й пункт — самый сложный. Существуют различные алгоритмы подсчета слогов в словах. В данном же случае, вы можете ограничиться подсчетом сочетаний "гласный-согласный". 
:Строго говоря, при расчете индекса сложности не следует считать составные слова и имена собственные как "сложные" слова, но это слишком усложнит сценарий.
'''Вычисление числа пи по алгоритму "Игла Баффона"'''
:В 18 веке, французский математик де Баффон (de Buffon) проделывал эксперимент, который заключался в бросании иглы, длиной "n", на деревянный пол, собранный из длинных и узких досок. Ширина всех досок пола одинакова и равна "d". Оказалось, что отношение общего числа бросков, к числу бросков, когда игла ложилась на щель, кратно числу пи. 
:Пользуясь '''Пример''': '''''Вычисление числа "пи"''''', напишите сценарий, который использовал бы метод Монте Карло для эмуляции "Иглы Баффона". Для простоты примите длину иглы раной ширине досок, n = d. 
:''Подсказка'': особое значение здесь имеют переменные, которые будут вычисляться как расстояние от центра иглы до ближайшей щели и величина угла между иглой и щелью. Для выполнения расчётов можно воспользоваться утилитой '''bc'''.
'''Шифрование по алгоритму Playfair (Wheatstone)'''
:Напишите сценарий, реализующий алгоритм шифрования Playfair (Wheatstone). В соответствии с этим алгоритмом, текст шифруется путем замены каждой 2-х символьной последовательности — "диграммы". Традиционно, в качестве ключа, используется матрица символов алфавита 5x5. 
:''C O D E S''
:''A B F G H''
:''I K L M N''
:''P Q R T U''
:''V W X Y Z''
:Матрица содержит все символы алфавита, за исключением символа "J", который представляет символ "I". Первая строка матрицы — произвольно выбранное слово, в данном случае — "CODES", далее следуют символы алфавита, в порядке слева-направо, исключая те, которые входят в состав первой строки. 
:Шифрование производится по следующему алгоритму: для начала, текст сообщения разбивается на диграммы (группы по 2 символа). Если в диграмму попадают два одинаковых символа, то второй символ удаляется, и формируется новая диграмма. Если в последней группе остаётся один символ, то такая "неполная" диграмма дополняется "пустым" символом, обычно "X". 
:''THIS IS A TOP SECRET MESSAGE''
:''TH IS IS AT OP SE CR ET ME SA''
:Каждая диграмма может подпадать под одно из следующих определений: 
:# Оба символа находятся в одной строке ключа. Тогда, каждый из них заменяется символом,стоящим справа в той же строке. Если это последний символ строки ключа, то он заменяется первым символом в той же строке ключа.
:# Оба символа находятся в одном столбце ключа. Тогда каждый из них заменяется на символ,стоящий ниже, в этом же столбце. Если это последний символ в столбце ключа, то он заменяется первым символом в том же столбце ключа.
:# Символы диграммы стоят в вершинах прямоугольника. Тогда каждый из них заменяетсясимволом из соседнего, по горизонтали, угла. Диграмма "TH" соответствует 3-му определению. 
:''G H''
:''M N''
:T U (Прямоугольник с вершинами "T" и "H")
:''T'' --> ''U''
:''H'' --> ''G''
:Диграмма "SE" соответствует 1-му определению.
:''C O D E S'' (Строка содержит оба символа "S" и "E")
:''S'' --> ''C'' (замена на первый символ в строке ключа)
:''E'' --> ''S''
:Дешифрация выполняется обратной процедурой, для случаев 1 и 2 — замена символом стоящим левее/выше. Для случая 3 — аналогично шифрации, т.е. заменяется символом из соседнего, по горизонтали, угла. ''Helen Fouche Gaines'', в своей классической работе "Elementary Cryptoanalysis"(1939), приводит подробное описание алгоритма ''Playfair'' и методы его реализации. 
:Этот сценарий должен иметь три основных раздела:
:# Генерация "ключевой матрицы", основывающейся на слове, которое вводит пользователь.
:# Шифрование "плоского" текста сообщения.
:# Дешифрование зашифрованного текста.
:Широкое применение, в этом сценарии, найдут массивы и функции.

'''Пожалуйста, не присылайте автору свои варианты решения упражнений. Если вы хотите впечатлить его своим умом и сообразительностью — присылайте обнаруженные вами ошибки и предложения по улучшению этой книги!'''

= Приложение L. Хронология =
Впервые этот документ вышел как ''HOWTO'' весной 2000 года. С тех пор он претерпел множество изменений и дополнений. Эта книга вряд ли появилась бы на свет без помощи всего Linux-сообщества, и особенно без помощи [http://www.tldp.org/ Linux Documentation Project]. 

 '''Таблица L-1. Хронология'''
{| class="wikitable" style="margin-left: 365px; margin-right: 0px;"
|-
! Редакция !! Дата !! Примечания
|-
| style="text-align:center;" | 0.1 || 14 Июня 2000 || Первая редакция.
|-
| style="text-align:center;" | 0.2 || 30 Октября 2000 || Исправление ошибок, сделаны добавления в тексте, добавлены примеры сценариев.
|-
| style="text-align:center;" | 0.3 || 12 Февраля 2001 || Добавления
|-
| style="text-align:center;" | 0.4 || 08 Июля 2001 || Полная переработка книги.
|-
| style="text-align:center;" | 0.5 || 03 Сентября 2001 || Исправления ошибок, дополнительный материал, реорганизация структуры книги.
|-
| style="text-align:center;" | 1.0 || 14 Октября 2001 || Стабильная редакция: исправления ошибок, реорганизация структуры, дополнительный материал.
|-
| style="text-align:center;" | 1.1 || 06 Января 2002 || Исправления ошибок, дополнительный материал.
|-
| style="text-align:center;" | 1.2 || 31 Марта 2002 || Исправления ошибок, дополнительный материал.
|-
| style="text-align:center;" | 1.3 || 02 Июня 2002 || Редакция "Мандарин" (TANGERINE): Исправления ошибок, дополнительный материал.
|-
| style="text-align:center;" | 1.4 || 16 Июня 2002 || Редакция "Манго" (MANGO): Исправления ошибок, дополнительный материал.
|-
| style="text-align:center;" | 1.5 || 13 Июля 2002 || Редакция "Папайя" (PAPAYA): Исправления ошибок, дополнительный материал.
|-
| style="text-align:center;" | 1.6 || 29 Сентября 2002 || Редакция "Гранат" (POMEGRANATE): Исправления ошибок, дополнительный материал.
|-
| style="text-align:center;" | 1.7 || 05 Января 2003 || Редакция "Кокос" (COCONUT): Исправления ошибок, дополнительный материал.
|-
| style="text-align:center;" | 1.8 || 10 Мая 2003 || Редакция "Плод хлебного дерева" (BREADFRUIT): Исправления ошибок, дополнительный материал.
|-
| style="text-align:center;" | 1.9 || 21 Июня 2003 || Редакция "Хурма" (PERSIMMON): Исправления ошибок, дополнительный материал.
|-
| style="text-align:center;" | 2.0 || 24 Августа 2003 || Редакция "Крыжовник" (GOOSEBERRY): Дополнительный материал.
|-
| style="text-align:center;" | 2.1 || 14 Сентября 2003 || Редакция "Черника" (HUCKLEBERRY): Исправления ошибок, дополнительный материал.
|-
| style="text-align:center;" | 2.2 || 31 Октября 2003 || Редакция "Клюква" (CRANBERRY): Дополнительный материал.
|-
| style="text-align:center;" | 2.3 || 03 Января 2004 || Редакция "Земляника" (STRAWBERRY): Исправления ошибок, дополнительный материал.
|-
| style="text-align:center;" | 2.4 || 25 Января 2004 || Редакция "Дыня" (MUSKMELON): Исправления ошибок.
|-
| style="text-align:center;" | 2.5 || 15 Февраля 2004 || Редакция STARFRUIT: Исправления ошибок, дополнительный материал.
|}

= Приложение M. Авторские права =
Авторские права на книгу "Advanced Bash-Scripting Guide", принадлежат '''Менделю Куперу''' (MendelCooper). Автор так же заявляет о своих правах на все предыдущие версии этого документа. Этим соглашением признаются и охраняются авторские права третьих лиц, предоставивших свои материалы для данной книги. Этот документ может распространяться исключительно на условиях Open Publication License (версия 1.0 или выше), [http://www.opencontent.org/openpub/]. Соблюдение следующих пунктов лицензии обязательно: 
# Распространение существенно измененных версий этого документа, запрещено без явного разрешения держателя прав.
# Запрещено распространение твёрдых (бумажных) копий книги, или её производных, без явного согласия держателя прав. 
''Пункт 1'', выше, явно запрещает вставлять логотипы компаний или навигационные элементы в титульную страницу или в текст документа, за исключением: 
# Некоммерческих организаций, таких как [http://www.tldp.org/ Linux Documentation Project] и [https://www.ibiblio.org/ Sunsite].
# Не "запятнавших" себя дистрибутивостроителей Linux, таких как '''''Debian''''', '''''Red Hat''''', '''''Mandrake''''' и других. 
Распространителям и издателям (включая электронные издания) запрещается наложение каких-либо ограничений, условий на данный документ, и все предыдущие его версии, без явного письменного разрешения автора. Начиная с этой версии, автор утверждает, что он ''НЕ'' связан какими-либо договорными отношениями, которые отменяли бы вышеизложенные высказывания. 
Практически, вы можете свободно распространять неизмененную электронную версию этой книги. Вы должны получить явное разрешение автора на распространение изменённых версий книги или её производных. Цель этого ограничения состоит в том, чтобы сохранить художественную целостность данного документа и предотвратить появление побочных "ветвей". 
Если вы выкладываете или распространяете этот документ, или какую-либо его предыдущую версию, на основе лицензии, иной, кроме перечисленных выше, тогда вы обязаны получить письменное разрешение автора книги, в противном случае ваши права на распространение документа являются незаконными. 
Это очень либеральные условия и они не должны препятствовать законному распространению и использованию этой книги. Автор особенно поощряет использование этой книги в учебных целях.
Права на коммерческое распространение книги могут быть получены у автора(thegrendel@theriver.com). 
Автор произвёл этот документ в соответствии с буквой и духом [http://www.tldp.org/manifesto.html LDP Manifesto].
{| class="wikitable"
|-
| '''Linux''' — это торговая марка, принадлежащая ''Линусу Торвальдсу'' (''Linus Torvalds''). 
'''UNIX''' и '''Unix''' — это торговая марка, принадлежащая Open Group. 
'''MS Windows''' — это торговая марка, принадлежащая Microsoft Corp. 
'''Pentium''' — это торговая марка, принадлежащая Intel, Inc. 
'''Scrabble''' — это торговая марка, принадлежащая Hasbro, Inc. 
'''''Все другие коммерческие торговые марки, упомянутые в данном документе, принадлежат их владельцам'''''.
|}
'''Hyun Jin Cha''' завершил перевод на Корейский язык версию 1.0.11 этой книги. Переводы на Испанский, Португальский, Французский, Немецкий, Итальянский, [http://gazette.linux.ru.net/rus/articles/index-abs-guide.html Русский] и Китайский языки находятся на стадии реализации. Если вы изъявите желание перевести этот документ на другой язык, то можете свободно выполнить этот перевод, основываясь на условиях, заявленных выше. В этом случае, автор хотел бы, чтобы его поставили в известность.

Gzip

2017-06-02T11:18:24Z

Vaal:

'''gzip, gunzip, gzcat''' — утилиты(команды) сжатия(упаковки) и распаковки файлов.

== Синтаксис ==
<source lang="bash"> [[gzip]] [ -acdfhlLnNrtvV19 ] [-S суффикс] [ имя ... ]
gunzip [ -acfhlLnNrtvV ] [-S суффикс] [ имя ... ]
gzcat [ -fhLV ] [ имя ... ]
</source>

== Описание ==

Утилита <code>[[gzip]]</code> уменьшает размер указанных файлов за счет кодирования по алгоритму Лемпела-Зива (Lempel-Ziv coding - LZ77). По возможности каждый файл заменяется одноименным файлом с расширением <code>.gz</code>, с сохранением тех же прав доступа, владельца и времени изменения. (Стандартное расширение - <code>-gz</code> для ОС ''VMS'', <code>z</code> для ''MSDOS'', ''OS/2 FAT'', ''Windows NT FAT'' и ''Atari''.) Если файлы не указаны или в качестве имени файла указан дефис (-), содержимое стандартного входного потока сжимается и направляется в стандартный выходной поток. Утилита <code>[[gzip]]</code> будет пытаться сжимать только обычные файлы. В частности, она будет '''''игнорировать символические связи'''''.

Если имя сжатого файла - слишком длинное для соответствующей файловой системы, утилита <code>[[gzip]]</code> его усекает. Утилита <code>[[gzip]]</code> пытается усечь только те части имени файла, которые длиннее 3 символов. (Часть имени ограничивается точками.) Если имя состоит только из коротких частей, усекаются самые длинные части. Например, если имена файлов должны быть не длиннее 14 символов, файл gzip.msdos.exe после сжатия получает имя gzi.msd.exe.gz. Имена '''''не усекаются''''' в системах, не имеющих ограничений на длину имени файла.

По умолчанию, утилита <code>[[gzip]]</code> сохраняет имя и время изменения сжимаемого файла. Они используются при разжатии файла с использованием опции -N. Это удобно, когда имя сжатого файла было усечено или когда после переноса не сохранилась временная отметка файла.

Сжатые файлы могут быть восстановлены в исходный вид с помощью <code>[[gzip]] -d</code>, <code>gunzip</code> или <code>gzcat</code>. Если исходное имя файла до сжатия не подходит для текущей файловой системы, на основе исходного имени конструируется новое, допустимое.

Утилита <code>gunzip</code> принимает список файлов в командной строке и заменяет каждый файл, имя которого заканчивается суффиксом <code>.gz</code>, <code>-gz</code>, <code>.z</code>, <code>-z</code>, <code>_z</code> или <code>.Z</code> и который начинается с соответствующей сигнатуры распакованным файлом без расширения. Утилита <code>gunzip</code> также распознает специальные расширения <code>.tgz</code> и <code>.taz</code> в качестве сокращений для <code>.tar.gz</code> и <code>.tar.Z</code>, соответственно. При сжатии утилита <code>[[gzip]]<code>, при необходимости, использует расширение <code>.tgz</code> вместо усечения имени файла с расширением <code>.tar</code>.

Утилита <code>gunzip</code> в настоящее время может разжимать файлы, созданные утилитами <code>[[gzip]]</code>, <code>zip</code>, <code>compress</code>, <code>compress -H</code> или <code>pack</code>. Формат входных данных определяется автоматически. При использовании первых двух форматов, <code>gunzip</code> проверяет 32-битовую контрольную сумму CRC. Для формата <code>pack<code>, <code>gunzip</code> проверяет длину распакованного файла. Стандартный формат <code>compress</code> не предполагает возможности проверки согласованности. Однако, утилита <code>gunzip</code> иногда способна выявить сбойный файл с расширением <code>.Z</code>. Если при разжатии файла с расширением <code>.Z</code> вы получаете сообщение об ошибке, не думайте, что этот файл корректен только потому, что стандартная утилита <code>uncompress</code> не сообщает об ошибках. Это просто означает, что стандартная утилита <code>uncompress</code> не проверяет входные данные и молча генерирует "мусорные" результаты. Формат <code>compress -H</code> в SCO (метод сжатия lzh) не включает контрольной суммы CRC, но позволяет выполнять определенные проверки согласованности.

Файлы, сжатые с помощью утилиты <code>zip</code> могут быть распакованы с помощью <code>[[gzip]]</code> только если они имеют один компонент, сжатый по методу 'deflation'. Эта возможность предназначена для упрощения преобразования файлов <code>tar.zip</code> в формат <code>tar.gz</code>. Для распаковки zip-файлов из нескольких компонентов используйте вместо <code>gunzip</code> утилиту <code>unzip</code>.

Команда <code>gzcat</code> идентична <code>gunzip -c</code>. (В некоторых системах утилита <code>zcat</code> может устанавливаться как <code>gzcat</code>, чтобы сохранилась исходная связь с <code>compress</code>.) Утилита <code>gzcat</code> распаковывает либо список файлов, заданный в командной строке, либо стандартный входной поток, и записывает распакованные данные в стандартный выходной поток. Утилита <code>gzcat</code> будет распаковывать файлы, имеющие соответствующую сигнатуру, независимо от наличия суффикса <code>.gz</code>.

Утилита <code>[[gzip]]</code> использует алгоритм Лемпела-Зива (Lempel-Ziv), как и утилиты <code>zip</code> и <code>PKZIP</code>. Степень сжатия зависит от размера входного файла и распределения типичных подстрок. Обычно файлы типа исходных кодов программ или текстов на английском языке упаковываются на 60-70%. Степень сжатия обычно намного лучше, чем достигаемая алгоритмом LZW (который используется в <code>compress</code>), кодированием Хафмана (Huffman coding, используемым утилитой <code>pack</code>), или адаптивным кодированием Хафмана (как в утилите <code>compact</code>).

Сжатие выполняется всегда, даже если сжатый файл несколько больше исходного. В худшем случае файл увеличивается на несколько байтов заголовка файла <code>[[gzip]]</code> плюс 5 байтов на каждый блок размером 32 Кбайта, что означает рост порядка 0.015% для больших файлов. Учтите, что фактическое количество блоков диска, занимаемых файлом, практически никогда не увеличивается. Утилита <code>[[gzip]]</code> сохраняет права доступа, владельца и временные отметки файлов при сжатии и распаковке.

== Опции ==

{| class="wikitable sortable"
|-
! Опции !! Значение
|-
| '''-a --ascii''' || Текстовый режим ascii: преобразует символы конца строки на базе локальных установок. Эта опция поддерживается только на некоторых системах, отличных от Unix. Для MSDOS, <code>CR LF</code> преобразуется при сжатии в <code>LF</code>, а <code>LF</code> преобразуется в <code>CR LF</code> при распаковке.
|-
| '''-c --stdout --to-stdout''' || Выдаёт результат в стандартный выходной поток; исходные файлы не изменяются. Если имеется несколько входных файлов, результат состоит из последовательности независимо сжатых компопнентов. Для получения большей степени сжатия, конкатенируйте все входные файлы перед сжатием.
|-
| '''-d --decompress --uncompress''' || Распаковка.
|-
| '''-f --force''' || Принудительно упаковывает или распаковывает файл даже если он имеет несколько связей или результирующий файл уже существует, или если сжатые данные читаются с терминала или записываются на терминал. Если входные данные не соответствуют формату, распознаваемому утилитой <code>[[gzip]]</code> и если указана также опция <code>--stdout</code>, копирует входные данные в стандартный выходной поток без изменений, что позволяет утилите <code>gzcat</code> работать как <code>cat</code>. Если опция <code>-f</code> не задана, и утилита не работает в фоновом режиме, <code>[[gzip]]</code> запрашивает у пользователя, надо ли перезаписывать существующий файл.
|-
| '''-h --help''' || Выдаёт справочную информацию и завершает работу.
|-
| '''-l --list''' || Для каждого сжатого файла выдаёт следующие поля:
compressed size: размер сжатого файла
uncompressed size: размер исходного файла
ratio: коэффициент сжатия (0.0% если неизвестен)
uncompressed_name: имя файла до сжатия
Размер разжатого файла имеет значение -1 для файлов, формат которых не поддерживается утилитой <code>[[gzip]]</code>, например, для сжатых файлов с расширением <code>.Z</code>. Для получения исходного размера файла, можно использовать команду:<source lang="bash">gzcat file.Z | wc -c</source>
В сочетании с опцией --verbose выдаются также следующие поля:
method: метод сжатия
crc: 32-битовая контрольная сумма (CRC) не сжатых данных
date & time: временная отметка исходного файла
В настоящее время поддерживаются следующие методы сжатия: <code>deflate</code>, <code>compress</code>, <code>lzh</code> (аналог <code>compress -H</code> в SCO) и <code>pack</code>. Для файлов не в формате <code>[[gzip]]</code> в качестве контрольной суммы crc выдаётся значение ffffffff.
Если указана опция <code>--name</code>, в качестве имени, даты и времени изменения исходного несжатого файла выдаются значения, хранящиеся в сжатом файле, если они доступны.
Если указана опция <code>--verbose</code> для всех файлов выдаются также общие размеры и коэффициенты сжатия, за исключением случаев, когда размеры не известны. Если указана опция <code>--quiet</code>, заголовки и общие значения не выдаются.
|-
| '''-L --license''' || Выдаёт лицензию <code>gzip</code> и завершает работу.
|-
| '''-n --no-name''' || При сжатии по умолчанию не сохраняет имя и временную отметку исходного файла. (Исходное имя всегда сохраняется, если имя после сжатия придётся усекать.) При распаковке не восстанавливает исходное имя файла, если оно есть (просто удаляет суффикс <code>[[gzip]]</code> у имени сжатого файла) и не восстанавливает исходную временную отметку, если она есть (она просто копируется из сжатого файла). Эта опция является стандартной при распаковке.
|-
| '''-N --name''' || При сжатии всегда сохраняет исходное имя файла и временную отметку; так и происходит по умолчанию. При распаковке восстанавливает исходное имя и временную отметку файла, если они доступны. Эта опция полезна в системах с ограничениями на длину имени файла или когда после переноса файлов была потеряна временная отметка.
|-
| '''-q --quiet''' || Подавляет выдачу любых предупреждений.
|-
| '''-r --recursive''' || Рекурсивно проходит по структуре каталогов. Если любое из имён файлов, указанных в командной строке, представляет собой каталог, утилита <code>[[gzip]]</code> перейдёт в этот каталог и сожмёт все находящиеся в нём файлы (или разожмёт их в случае <code>gunzip</code>).
|-
| '''-S .suf --suffix .suf''' || Использует суффикс .suf вместо .gz. Можно задать любой суффикс, но не стоит использовать другие суффиксы, кроме .z и .gz, чтобы избежать недоразумений при переносе файлов на другие системы. Пустой суффикс вынуждает программу gunzip попытаться распаковать все указанные файлы, независимо от суффикса, как в следующем примере:
<source lang="bash">gunzip -S "" * (*.* for MSDOS)</source>
В прежних версиях <code>[[gzip]]</code> использовался суффикс <code>.z</code>. Этот суффикс был изменен, чтобы избежать конфликтов с программой <code>pack</code>.
|-
| '''-t --test''' || Проверка. Проверяет целостность сжатого файла.
|-
| '''-v --verbose''' || Подробная выдача. Выдаёт имя и процент сжатия для каждого сжимаемого или разжимаемого файла.
|-
| '''-V --version''' || Версия. Выдаёт номер версии и использованные опции компиляции и завершает работу.
|-
| '''-# --fast --best''' || Управляет скоростью сжатия, задавая её указанной цифрой #, причем опция -1 или --fast задаёт самый быстрый метод (с наименьшим коэффициентом сжатия), а -9 или --best задаёт самый медленный метод (с наибольшим коэффициентом сжатия). Стандартный уровень сжатия — -6 (т.е. имеется определённое смещение в сторону повышения коэффициента сжатия за счёт снижения скорости).
|}

== Расширенные варианты использования ==
Можно конкатенировать несколько сжатых файлов. В этом случае утилита <code>gunzip</code> будет извлекать все файлы сразу. Например:
<source lang="bash">
gzip -c file1 > foo.gz
gzip -c file2 >> foo.gz
</source>
После этого команда:
<source lang="bash">
gunzip -c foo
</source>
будет эквивалентна команде:
<source lang="bash">
cat file1 file2
</source>
В случае повреждения одного из компонентов файла <code>.gz</code>, другие компоненты можно восстановить (если удалить поврежденный компонент). Однако большей степени сжатия можно достичь, сжимая все компоненты сразу:
<source lang="bash">
cat file1 file2 | gzip > foo.gz
</source>
сжимается лучше, чем:
<source lang="bash">
gzip -c file1 file2 > foo.gz
</source>
Если необходимо переупаковать конкатенированые файлы для получения большей степени сжатия, используйте команду следующего вида:
<source lang="bash">
gzip -cd old.gz | gzip > new.gz
</source>
Если сжатый файл состоит из нескольких компонентов, размер исходного файла и контрольная сумма CRC, выдаваемые опцией <code>--list</code>, относятся только к последнему компоненту. Если необходимо узнать исходный размер всех компонентов, можно использовать команду:
<source lang="bash">
gzip -cd file.gz | wc -c
</source>
Если необходимо создать единый архивынй файл с несколькими компонентами так, чтобы можно было извлекать независимо друг от друга, используйте архиватор типа tar или zip. Утилита GNU <code>tar<code> поддерживает опцию <code>-z</code> для прозрачного вызова утилиты <code>[[gzip]]</code>. Утилита <code>[[gzip]]</code> дополняет программу <code>[[tar]]</code>, но не заменяет её.

== Среда ==

Переменная среды GZIP может задавать набор стандартных опций для <code>[[gzip]]</code>. Эти опции интерпретируются первыми и могут переопределяться явными параметрами командной строки. Например:

для sh: <source lang="bash">GZIP="-8v --name"; export GZIP</source>
для csh: <source lang="bash">setenv GZIP "-8v --name"</source>
для MSDOS: <source lang="dos">set GZIP=-8v --name</source>

В ОС Vax/VMS соответствующая переменная среды называется GZIP_OPT, чтобы избежать конфликта с именем программы.

== Диагностика ==

Статус выхода обычно имеет значение '''''0;''''' если возникает ошибка, статус выхода имеет значение '''''1'''''. Если выдавались предупреждения, статус выхода имеет значение '''''2'''''.

Usage: gzip [-cdfhlLnNrtvV19] [-S suffix] [file ...]
В командной строке заданы недопустимые опции.

'''''file: not in gzip format'''''
Указанный программе <code>gunzip</code> файл не был сжат утилитой <code>[[gzip]]</code>.

'''''file: Corrupt input. Use gzcat to recover some data.'''''
Сжатый файл был поврежден. Данные до точки сбоя могут быть восстановлены с помощью команды
<source lang="bash">
gzcat file > recover
</source>
'''''file: compressed with xx bits, can only handle yy bits'''''
Файл был сжат (с помощью алгоритма LZW) программой, способной работать с большим количеством битов, чем код распаковки на данной машине. Сожмите файл заново с помощью утилиты <code>[[gzip]]</code>, сжимающей лучше и использующей меньше памяти.
'''''file: already has .gz suffix -- no change'''''
Предполагается, что файл уже сжат. Переименуйте файл и попробуйте ещё раз.
'''''file already exists; do you wish to overwrite (y or n)?'''''
Ответьте утвердительно (y), если хотите заменить существующий файл, или отрицательно (n), если не хотите.
'''''gunzip: corrupt input'''''
Был получен сигнал SIGSEGV, что обычно вызвано повреждением входного файла.
'''''xx.x%'''''
Процент входного файла, сэкономленный за счет сжатия. (Только для опций -v и -l.)
'''''-- not a regular file or directory: ignored'''''
Если входной файл не является обычным файлом или каталогом, (т.е. это символическая связь, сокет, именованный канал FIFO или специальный файл устройства, он не изменяется.
'''''-- has xx other links: unchanged'''''
Входной файл имеет несколько связей; он не изменняется. Поробнее о связях см. на странице справочного руководства ln(1). Для принудительного сжатия файлов с несколькими связями используйте флаг -f.

== Потенциальные проблемы ==
При записи сжатых данных на ленту обычно необходимо дополнять результат нулями до границы блока. При чтении данных и передаче их для распаковки утилите gunzip, она выявляет дополнительный "мусор" после сжатых данных и, по умолчанию, выдает предупреждение. Чтобы подавить выдачу этого предупреждения, используйте опцию --quiet. Эту опцию можно задать в переменной среды GZIP, как в следующем примере:

для sh: <source lang="bash">GZIP="-q"; tar -xfz --block-compress /dev/rst0</source>
для csh: <source lang="bash">(setenv GZIP -q; tar -xfz --block-compr /dev/rst0)</source>

В примере выше утилита <code>[[gzip]]</code> вызывается неявно опцией <code>-z</code> утилиты <code>GNU [[tar]]</code>. Проверьте, что при чтении и записи сжатых данных на ленты используется один и тот же размер блока (опция -b программы <code>[[tar]]</code>). (В этом примере предполагается использование GNU-версии программы <code>[[tar]]</code>.)

== Ошибки ==

Опция <code>--list</code> выдаёт некорректные размеры, если они превышают 2 Гбайта. Опция <code>--list</code> выдает значение размера <code>-1</code> и контрольной суммы crc - ffffffff, если сжатый файл находится на носителе, не допускающем произвольную адресацию (non seekable media).

В некоторых редких случаях опция <code>--best</code> даёт худшее сжатие, чем стандартный уровень сжатия (-6). Некоторые особо избыточные файлы сжимаются утилитой <code>compress</code> лучше, чем утилитой <code>[[gzip]]</code>.

== Примечания ==

Исходные коды для утилиты <code>[[gzip]]</code> доступны в пакете SUNWgzipS.
== Авторские права ==
Copyright (C) 1987, 88, 89, 90, 91, 92, 1993 Free Software Foundation, Inc.

Эта программа является свободно распространяемым программным обеспечением; вы можете распространять и/или изменять ее в соответствии с условиями Генеральной общественной лицензии GNU (GNU General Public License), опубликованной Фондом свободно распространяемого программного обеспечения (Free Software Foundation); либо версии 2, либо (по вашему выбору) любой более поздней версии.

Эта программа распространяется в надежде, что она окажется полезной, но БЕЗО ВСЯКИХ ГАРАНТИЙ; даже без подразумеваемой гарантии ТОВАРНОЙ ПРИГОДНОСТИ или ПРИГОДНОСТИ ДЛЯ КОНКРЕТНОЙ ЦЕЛИ. Подробнее см. в Генеральной общественной лицензии GNU.

Вы должны были получить экземпляр Генеральной общественной лицензии GNU вместе с этой программой; если же нет, обратитесь за ней по адресу Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.

Bzip2

2017-06-02T06:40:18Z

Vaal: Новая страница: «'''bzip2''' — бесплатная свободная утилита командной строки с открытым исходным кодом для сж…»

'''bzip2''' — бесплатная свободная утилита командной строки с открытым исходным кодом для сжатия данных, реализация алгоритма Барроуза — Уилера.

Разработана и впервые опубликована Джулианом Сюардом (Julian Seward) в июле 1996 года (версия 0.15). Стабильность и популярность компрессора росли в течение нескольких лет, и версия 1.0 была опубликована в конце 2000 года.

== Эффективность ==

В соответствии с традициями UNIX, <code>bzip2</code> единовременно может выполнять только одну операцию: либо сжатие, либо распаковку и только для одного файла. При сжатии <code>bzip2</code> добавляет к имени файла расширение «<code>.bz2</code>». Для упаковки нескольких файлов их сперва архивируют в один файл утилитой <code>[[tar]]</code>, а затем сжимают при помощи <code>bzip2</code>. Такие архивы обычно имеют расширение «<code>.tar.bz2</code>».

<code>bzip2</code> сжимает большинство файлов эффективнее, но медленнее, чем более традиционные утилиты <code>gzip</code> или <code>zip</code>. В этом отношении он похож на другие современные алгоритмы сжатия.

<code>bzip2</code> выполняет сжатие данных с существенной нагрузкой на CPU (что обусловлено его математическим аппаратом). <code>bzip2</code> применяют, если нет ограничений на время сжатия и на нагрузку на CPU, например, для разовой упаковки большого объёма данных.

В некоторых случаях <code>bzip2</code> уступает по эффективности сжатия архиваторам <code>7-Zip</code> (метод сжатия LZMA) и <code>rar</code>. Согласно данным автора программы от 2005 года, метод сжатия <code>bzip2</code> уступает по эффективности сжатия на 10‑15% наилучшим методом, известным на тот момент (PPM). На данный момент наиболее эффективно сжимают различные реализации метода PAQ. Однако, использование данного метода крайне затруднено по причине низкой производительности (сжатие требует больших временных затрат), но при этом в 2 раза быстрее при сжатии и в 6 раз быстрее при распаковке.

== Описание алгоритма ==

Метод сжатия <code>bzip2</code> работает следующим образом:
* несжатые данные делятся на блоки фиксированного размера;
* выполняется преобразование Барроуза — Уилера для превращения последовательностей многократно чередующихся символов в строки одинаковых символов;
* применяет преобразование Move-To-Front(MTF);
* используется кодирование Хаффмана.

Приблизительный размер блока можно выбрать при помощи аргументов командной строки («<code>-1</code>» для 100 килобайт, «<code>-2</code>» для 200 КБ, …, «<code>-9</code>» для 900 КБ). Каждый блок сжимается независимо, сжатые блоки записываются последовательно друг за другом, в начале каждого используется 48-битная последовательность — магическое число 0x314159265359 (в кодировке ASCII при выравнивании на границу байта отображается как «1AY&SY»), то есть запись первых десятичных цифр числа Пи в формате BCD. Конец файла помечается 48-битной константой 0x177245385090, представляющей собой корень из числа Пи.

Предшественник <code>bzip2</code>, программа <code>bzip</code>, вместо кодирования Хаффмана использовала арифметическое кодирование. Из‑за патентных ограничений от этого алгоритма отказались.

== Использование ==

Примеры использования <code>bzip2</code>.

<source lang="bash">
# Команда для сжатия файла «file»
bzip2 file
# или
bzip2 --compress file

# Команда для распаковки файла «file.bz2»
bzip2 -d file.bz2
# или
bzip2 --decompress file.bz2
# или
bunzip2 file.bz2
# bunzip2 - копия bzip2 или ссылка на bzip2
</source>

Аргументы командной строки <code>bzip2</code> в основном такие же, как и у утилиты <code>gzip</code>.

<source lang="bash">
# Команда для распаковки архива tar, сжатого bzip2
bzip2 -cd file.tar.bz2 | tar -xvf -
# или
bzip2 --stdout --decompress file.tar.bz2 \
| tar --extract --verbose --file -

# Команда для создания архива tar, сжатого bzip2
tar -cvf - files | bzip2 -9 > file.tar.bz2
# или
tar --create --verbose --file - files \
| bzip2 -9 > file.tar.bz2

</source>

Версия GNU <code>[[tar]]</code> поддерживает флаг «<code>-j</code>» («<code>--bzip2</code>»), который позволяет создавать и распаковывать файлы «<tt>tar.bz2</tt>» без использования перенаправлений ввода-вывода (pipeline). Пример:
<source lang="bash">
# Упаковка данных в архив tar и сжатие bzip2 при помощи GNU tar
tar -cvjf file.tar.bz2 list_of_files
# или
tar --create --verbose --bzip2 --file file.tar.bz2 list_of_files

# Распаковка архива tar, сжатого bzip2 при помощи GNU tar
tar -xvjf file.tar.bz2
# или
tar --extract --verbose --bzip2 --file file.tar.bz2

</source>

Современные версии GNU <code>tar</code> могут автоматически определить метод сжатия данных, и поэтому флаг «<code>-j</code>» («<code>--bzip2</code>») можно не использовать. Пример:
<source lang="bash">
tar -xvf file.tar.bz2
# или
tar --extract --verbose --file file.tar.bz2
</source>

Кроме того, существует набор утилит для выполнения поиска, вывода, восстановления и сравнения данных в формате <code>bzip2</code>:
* <code>bzcat</code> — распаковка данных и вывод на терминал;
* <code>bzmore</code>, <code>bzless</code> — распаковка данных и постраничный вывод на терминал;
* <code>bzcmp</code> — распаковка двух файлов, сравнение содержимого и сообщение результата: «равно» или «не равно»;
* <code>bzdiff</code> — распаковка двух файлов, сравнение содержимого и вывод различий;
* <code>bzgrep</code>, <code>bzegrep</code>, <code>bzfgrep</code> — распаковка данных и поиск в распакованном;
* <code>bzip2recover</code> — распаковка любых блоков, которые только можно распаковать.

== Формат файла ==

Архив «<code>.bz2</code>» содержит поток (stream) сжатых данных. Слово «поток» употребляется, так как данные нельзя разделить логически и блоки данных сжимаются независимо друг от друга. Сжатые данные состоят из следующих полей:
* заголовок размером 4 байта;
* ноль или более блоков сжатых данных различного размера;
* маркер, обозначающий конец сжатых данных и контрольная сумма(CRC) размером 32 бита, вычисленная для всего потока;
* несколько неиспользуемых бит для дополнения размера потока до целого количества байт.

{| class="wikitable"
|-
! Название поля || Размер поля в битах || Описание
|-
| .magic || 16 || <code>BZ</code> — константа, сигнатура, магическое число.
|-
| .version || 8 || Байт, кодирующий номер версии.
; <code>0</code> : Версия 1 (bzip1). Deprecated.
; <code>h</code> : Версия 2 (bzip2). «h» от англ. '''H'''uffman coding}}.
|-
| .hundred_k_blocksize || 8 || Размер блока несжатых данных в сотнях kB.
; <code>1</code> : Одна сотня kB (100 kB).
; <code>2</code> : Две сотни kB (200 kB).
; … : И так далее
; <code>9</code> : Девять сотен kB (900 kB).
|-
| .compressed_magic || 48 || <code>0x314159265359</code> — константа, число Пи, записанное в двоично-десятичном коде(BCD).
|-
|| .crc || 32 || Контрольная сумма, рассчитанная для текущего блока.
|-
| .randomised || 1 ||
; <code>0</code> : normal
; <code>1</code> : randomised (deprecated)
|-
| .origPtr || 24 || starting pointer into Преобразование Барроуза — Уилера(BWT) for after untransform
|-
| .huffman_used_map || 16 || bitmap, of ranges of 16 bytes, «имеется»/«отсутствует»
|-
|| .huffman_used_bitmaps || 0..256 || bitmap, of symbols used, «имеется»/«отсутствует» (кратно 16)
|-
| .huffman_groups || 3 || Число от 2 до 6, количество используемых таблиц Хаффмана.
|-
| .selectors_used || 15 || Число, показывающее сколько раз выполнялась смена таблицы Хаффмана (каждые 50 байт).
|-
| *.selector_list || 1..6 || zero-terminated bit runs (0..62) of Move-To-Front(MTF)'ed Huffman table (*selectors_used)
|-
| .start_huffman_length || 5 || 0..20 starting bit length for Huffman deltas
|-
| *.delta_bit_length || 1..40 ||
; <code>0</code> : next symbol
; <code>1</code> : alter length
{ 1=>decrement length; 0=>increment length } (*(symbols+2)*groups)
|-
| .contents || 2..∞ || Huffman encoded data stream. Продолжается до конца блока. Максимальная длина равна formatnum:7372800 бит.
|-
| .eos_magic || 48 || <code>0x177245385090</code> — константа, квадратный корень из числа Пи (sqrt(pi)) в двоично-десятичном коде(BCD).
|-
| .crc || 32 || Контрольная сумма, рассчитанная для всего потока.
|-
| .padding || 0..7 || Неиспользуемые биты (от 0 до 7). Назначение: увеличение размера архива до размера, кратного одному байту (8 битам) (выравнивание данных).
|-
|}

Максимальный размер не сжатого блока равен 900 kB. Если блок состоит из одного повторяющегося символа, после кодирования RLE блок займёт около 46 MB (45899236 байт), а после выполнения всех операций размер файла <code>.bz2</code> составит 46 байт. Если повторяющийся символ будет иметь код 251, размер файла <code>.bz2</code> составит 40 байт, а коэффициент сжатия (compression ratio) будет равен 1147480.9:1.

== Ссылки ==

* [http://www.bzip.org/ Официальный сайт bzip.org]
* [http://faqs.lomonline.de/introdution-to-bzip2/ Введение в bzip2]

Tar

2017-06-02T06:18:41Z

Vaal:

'''tar''' (от англ. '''t'''ape '''ar'''chive) — формат битового потока или файла архива, а также название традиционной для Unix программы для работы с такими архивами. Программа <code>tar</code> была стандартизирована в POSIX.1-1998, а также позднее в POSIX.1-2001. Первоначально программа <code>tar</code> использовалась для создания архивов на магнитной ленте, а в настоящее время <code>tar</code> используется для хранения нескольких файлов внутри одного файла, для распространения программного обеспечения, а также по прямому назначению — для создания архива файловой системы. Одним из преимуществ формата <code>tar</code> при создании архивов является то, что в архив записывается информация о структуре каталогов, о владельце и группе отдельных файлов, а также временны́е метки файлов.

Как и другие утилиты Unix, <code>tar</code> — специализированная программа, которая следует философии Unix «делать только одну вещь» (в данном случае — работать с архивами формата <code>tar</code>), «но делать её хорошо». Поэтому <code>tar</code> не создаёт сжатых архивов, а использует для сжатия внешние утилиты, такие, как <code>gzip</code> и <code>bzip2</code>. Ранее для сжатия использовалась также утилита <code>compress</code>, которая практически вышла из употребления.

== Примечание ==
Из-за достаточно поздней стандартизации существует несколько похожих, но не до конца совместимых форматов. В частности, различие между ''GNU tar'' и ''SUN Solaris tar'' наблюдается при длине имени файла, включаемого в архив, более 100 символов или размере включаемого в архив файла более 8 ГБ.

== Расширения имён файлов ==
Для файлов, содержащих архивы tar, традиционно применяется расширение имени файла <code>.tar</code>. В случае дополнительного сжатия другими программами применяются следующие расширения:

* gzip: <code>.tar.gz</code>, <code>.tgz</code> (в случае ограничений файловой системы на длину расширения), <code>.tar.gzip</code>
* bzip2: <code>.tar.bz2</code>, <code>.tar.bzip2</code>, <code>.tbz2</code>, <code>.tb2</code>, <code>.tbz</code>
* compress: <code>.tar.Z</code>, <code>.taz</code>
* LZMA: <code>.tar.lzma</code>
* XZ: <code>.tar.xz</code>, <code>.txz</code>
* lzop: <code>.tar.lzo</code>, <code>.tzo</code>
* lzip: <code>.tar.lz</code>, <code>.tlz</code>

== Синтаксис ==
tar [-опции] <имя файла tar> [файлы, которые необходимо поместить в архив при сжатии]
Опции:
* -c, --create создать архив

== Примеры ==
Создание bar.tar из файла или каталога foo:
<source lang="bash">
tar -cvf bar.tar foo
</source>
Извлечение содержимого bar.tar в текущий каталог:
<source lang="bash">
tar -xvf bar.tar
</source>

== Tarpipe ==
Tarpipe — процесс создания tar-архива в stdout и последующего извлечения содержания архива в другом каталоге из stdin. Это очень удобный метод копирования содержания одной файловой системы в другую, так как происходит полное копирование, включая атрибуты файлов, символические ссылки, файлы устройств.
<source lang="bash">
tar -C "каталог_источника" -cf - . | tar -C "каталог_назначения" -xvf -
</source>


; Tar over SSH
<source lang="bash">
tar -C каталог_источника -czpvf - . | ssh user@host "cat > каталог_назначения/backup.tgz"
</source>

; Tar & 7-zip
Чтобы сделать резервную копию каталога:
<source lang="bash">
tar cf - directory | 7za a -si directory.tar.7z
</source>
Чтобы восстановить из резервной копии:
<source lang="bash">
7za x -so directory.tar.7z | tar xf -
</source>

== Ссылки ==
* [http://www.gnu.org/software/tar/ Официальная страница] на сайте GNU
* [http://savannah.gnu.org/cgi-bin/viewcvs/*checkout*/tar/tar/src/tar.h?content-type=text/plain Файл 'tar.h' из исходных текстов GNU tar]
* [http://www.mkssoftware.com/docs/man4/tar.4.asp Подробная информация о заголовках архивов tar и USTAR]
* [http://www.openbsd.org/cgi-bin/man.cgi?query=tar man-страница tar(1)] из OpenBSD
* [http://www.freebsd.org/cgi/man.cgi?query=tar&apropos=0&sektion=0&manpath=FreeBSD+8-current&format=html man-страница tar(1)] из FreeBSD

Rsync — Cинхронизация файлов и каталогов в двух местах

2017-06-01T07:45:33Z

Vaal: Новая страница: «[http://rsync.samba.org/ rsync] (англ. Remote Synchronization) — программа для UNIX-подобных систем, которая выполня…»

[http://rsync.samba.org/ rsync] (англ. Remote Synchronization) — программа для UNIX-подобных систем, которая выполняет синхронизацию файлов и каталогов в двух местах с минимизированием трафика, используя кодировку данных при необходимости.

__TOC__

==Примеры работы с данными на локальной машине==

===Простое копирование файлов===
В принципе, команда ''ср'' отлично выполняет свою функцию, за исключением небольшой прихоти -- при копировании больших файлов хотелось бы знать сколько времени осталось до завершения операции (т.е. всего-навсего нужно вывести прогресс операции копирования).

Данную задачу можно решить несколькими способами:

1) Использовать команду [[Scp — Команда безопасного сетевого копирования файлов|scp]] (потребует ввода пароля пользователя, а также ввода полного пути к каталогам):
<source lang="bash">scp -r <что копировать> localhost:<куда копировать></source>

2) Использовать команду rsync с ключом --progress:
<source lang="bash">rsync --progress -av <что копировать> <куда копировать></source>

При копировании каталогов (а не файлов) в последнем случае следует обратить внимание на знак "/" замыкающий имя каталога-источника, т.к. команда rsync будет интерпретировать результат по-разному:

<source lang="bash">rsync --progress -av <каталог-источник> <каталог-назначения/></source>
<source lang="bash">rsync --progress -av <каталог-источник/> <каталог-назначения/></source>

Наличие завершающих слешей "/" обязательно, иначе результат копирования будет содержать корневую папку <каталог-источник> внутри <каталога-назначения>.

-----

Копирование файла ''а'' из ''dir1'' в ''dir2'':
<source lang="bash">scp /home/dir1/a localhost:/home/dir2/</source>

Копирование каталога из ''dir1'' в ''dir2'':
<source lang="bash">scp -r /home/dir1/ localhost:/home/dir2/</source>

Копирование файла ''а'' из ''dir1'' в ''dir2'':
<source lang="bash">rsync --progress -av ~/dir1/a ~/dir2/</source>

Копирование файлов из ''dir1'' в ''dir2'':
<source lang="bash">rsync --progress -av ~/dir1/ ~/dir2/</source>

Копирование самой директории ''dir1'' (со всем содержимым) в ''dir2'':
<source lang="bash">rsync --progress -av ~/dir1 ~/dir2/</source>

===Синхронизация каталогов===

Точная копия каталогов (удаление всех файлов из ''dir2'', которых нет в ''dir1''):
<source lang="bash">rsync --delete -av ~/dir1/ ~/dir2/</source>

Исключить каталоги, синхронизация которых не требуется (например, каталог ''dir3'' находящийся в ''dir1'' при копировании последнего в ''dir2'' будет пропущен):
<source lang="bash">rsync -av ~/dir1/ --exclude="./~dir3/" ~/dir2/</source>

Двусторонняя синхронизация (объединить содержимое ''dir1'' и ''dir2'')
<source lang="bash">rsync -av ~/dir1/ ~/dir2/ && rsync -av ~/dir2/ ~/dir1/</source>

=== Как копировать большие файлы и докопировать их в случае обрыва связи? ===

Нужно использовать ключи <tt>--partial</tt> (<tt>-P</tt>) и <tt>--append-verify</tt>.

Ключ <tt>--partial</tt> говорит о том, что нужно оставлять даже не полностью скопированные файлы,
а <tt>--append-verify</tt> говорит о том, что если файл уже есть нужно проверить, возможно он не полностью синхронизирован,
и синхронизировать остаток.
Пример команды, которая поможет докачать файл в случае разрыва соединения с удалённым сервером hostname:
<source lang="bash">rsync -av --partial --rsh=ssh username@hostname:filename./</source>
Подробнее:

* http://unix.stackexchange.com/questions/48298/can-rsync-resume-after-being-interrupted

==Работа с удалённой машиной==

Копирование через SSH (аналог scp)
<source lang="bash">rsync -av --rsh=ssh user@host:dir1/ ~/dir1/</source>

По умолчанию, в случае разрыва соединения частично переданные файлы будут удалены. Чтобы изменить это поведение необходимо указать ключ ''--partial''. Так же можно использовать ''--partial-dir=DIR'' чтобы в место назначения попадали только полностью переданные файлы.
Очень полезно при использовании плохих каналах связи.

==Дополнительная информация==
* [http://alexandr.sysoev.ru/node/66 10 примеров удаленного копирования файлов]
* [http://unixstuff.ru/files/74875f10c5ff1a33eecb0d86c5f98f9b-8.html Перевод документации]
* [http://cworld.org.ua/news/rsync-backup-debian/ Синхронизация файлов с помощью rsync (Debian)]
* [http://wiki.enchtex.info/tools/console/rsync rsync - синхронизация файлов]

Setfacl

2017-05-18T12:11:22Z

Vaal:

==Введение==
'''A'''ccess '''C'''ontrol '''L'''ist предоставляет расширенный и более гибкий механизм распределения прав файловых систем. Он предназначен для расширения прав доступа к файлам <code>UNIX</code>. ACL позволяет устанавливать разрешения любым пользователям или группам для различных файловых ресурсов.

==Установка==
Установка ACL доступна из репозитория rhel-server-eus-rpms или rhel-server-rpms пакетов: 
# yum install -y acl

==Настройка==

===Включение ACL===
Для включения ACL - отредактируйте файл '''/etc/fstab''' и добавьте атрибут '''acl''' к опциям раздела, где полагается использование ACL:

<pre>
#
# /etc/fstab: static file system information
#
# <file system> <dir> <type> <options> <dump> <pass>
none /dev/pts devpts defaults 0 0
none /dev/shm tmpfs defaults 0 0

UUID=5de01fca-7c63-49b0-9b2b-8b1790f8428e swap swap defaults 0 0

UUID=8e5259dd-26fc-411a-88e2-f38d4dc36724 /home reiserfs defaults,acl 0 1

UUID=c18f753e-0039-49bd-930f-587d48b7e083 / reiserfs defaults 0 1
</pre>

Сохраните файл. Переподключите раздел:
# mount -o remount /home

===Установка прав ACL===
Для изменения ACL используйте команду '''setfacl'''. Для добавления прав используйте '''setfacl -m'''.

Добавление прав какому-нибудь пользователю:
# setfacl -m "u:username:permissions"
или
# setfacl -m "u:uid:permissions"

Для добавления прав какой-нибудь группе:
# setfacl -m "g:groupname:permissions"
или
# setfacl -m "g:gid:permissions"

Удаление всех расширений ACL:
# setfacl -b

Удаление всех записей:
# setfacl -x "entry"

Проверка установленных разрешений:
# getfacl filename

=== Параметры ===

{| class="wikitable sortable"
|-
! Опции !! Значение
|-
| '''-m, --modify=acl''' || Добавить и модифицировать существующие записи [[ACL]]
|-
| '''-M, --modify-file=file''' || Добавить и модифицировать существующие записи [[ACL]] взятые из указанного файла
|-
| '''-x, --remove=acl''' || Удалить указанные [[ACL]] права взятые из указанного файла
|-
| '''-b, --remove-all''' || Удалить все [[ACL]] права с объекта, сохраняя основные права
|-
| '''-k, --remove-default''' || Удалить с объекта [[ACL]] по умолчанию. Если таковых на объекте нет, предупреждение об этом выдаваться не будет
|-
| '''--set=acl''' || Установить новые указанные права [[ACL]], удаляя все существующие. Необходимо, чтобы наравне с задаваемыми правилами [[ACL]] были также указаны стандартные права Unix, в противном случае будет давать ошибку
|-
| '''--set-file=file''' || Установить новые указанные права [[ACL]], взятые из указанного файла, удаляя все существующие. Необходимо, чтобы наравне с задаваемыми правилами [[ACL]] были также указаны стандартные права Unix, в противном случае будет давать ошибку
|-
| '''--mask''' || Пересчитать маску действующих прав
|-
| '''-n, --no-mask''' || Не пересчитывать маску действующих прав
|-
| '''-d, --default''' || Установить [[ACL]] по умолчанию на объект
|-
| '''-R, --recursive''' || Рекурсивное назначение (удаление) прав, тобишь пройтись по всем подкаталогам
|-
| '''-L, --logical''' || Логический обход, следующий символическим ссылкам
|-
| '''-P, --physical''' || Физический обход, не следующий символическим ссылкам
|-
| '''--restore=file''' || Восстанавить [[ACL]] права на объекты из ранее созданного файла с правами
|-
| '''--test''' || Тестовый режим
|-
| '''-v, --version''' || Вывод версии
|-
| '''-h, --help''' || Вывод справки
|}

==Примеры==

Установить все разрешения на файл "abc" для пользователя johny:
# setfacl -m "u:johny:rwx" abc
Проверить разрешения:
# getfacl abc

<pre>
# file: abc
# owner: someone
# group: someone
user::rw-
user:johny:rwx
group::r--
mask::rwx
other::r--
</pre>

Изменение разрешений для пользователя johny:
# setfacl -m "u:johny:r-x" abc
Проверка разрешений:
# getfacl abc

<pre>
# file: abc
# owner: someone
# group: someone
user::rw-
user:johny:r-x
group::r--
mask::r-x
other::r--
</pre>

Удаление всех записей расширения ACL:
# setfacl -b abc
Проверка разрешений:
# getfacl abc

<pre>
# file: abc
# owner: someone
# group: someone
user::rw-
group::r--
other::r--
</pre>

===Вывод команды ls===
При использовании команды '''ls -l''' можно заметить '''+'''(знак плюс) следующий за правами unix, предупреждающий об использовании расширений ACL для файла.

<pre>
$ ls -l /dev/audio
crw-rw----+ 1 root audio 14, 4 nov. 9 12:49 /dev/audio

$ getfacl /dev/audio
getfacl: Removing leading '/' from absolute path names
# file: dev/audio
# owner: root
# group: audio
user::rw-
user:solstice:rw-
group::rw-
mask::rw-
other::---
</pre>

==Повышение безопасности веб-сервера==

Для повышения безопасности веб-сервера добавьте расширенные права на домашнюю директорию и/или директорию сайта только для пользователя '''http'''.

Перейдите в домашнюю директорию:
# cd /home
Добавьте разрешение '''+x''' для пользователя http с помощью ACL:
# setfacl -m "u:http:--x" homeusername/
Теперь удалите права rx разрешающие использование директории другим пользователям:
# chmod o-rx homeusername/
Проверьте изменения:

<pre># file: username/
# owner: username
# group: users
user::rwx
user:http:--x
group::r-x
mask::r-x
other::---
</pre>
Как мы можем видеть, другие пользователи не имеют доступа, но для пользователя http установлен атрибут "x", что разрешает ему просмотр пользовательской директории и дает доступ к веб-страницам пользователя. Это справедливо, если веб-сервер работает от имени пользователя http. По умолчанию пользователь http не наделён такими полномочиями.

== Ссылки ==
* [https://www.opennet.ru/man.shtml?topic=setfacl&category=1&russian=2 OpenNET setfacl мануал] — Мануал по setfacl

Getfacl

2017-05-18T11:57:11Z

Vaal:

'''getfacl''' — команда с помощью которой можно посмотреть список текущих ACL.

getfacl [параметры] файлы

Поскольку мы еще не определяли ACL на файлы, то в примере использования программы будут показаны права по умолчанию.

<pre>$ getfacl test
# file: test
# owner: artur
# group: users
user::rw-
group::r--
other::r--
$</pre>

== Параметры ==

{| class="wikitable sortable"
|-
! Опция !! Значение
|-
| '''-a, --access''' || Вывести только права [[ACL]]
|-
| '''-d, --default''' || Вывести только стандартные права
|-
| '''-c, --omit-header''' || Не выводить комментарии в заголовке
|-
| '''-e, --all-effective''' || Вывести все эффективные права
|-
| '''-E, --no-effective''' || Вывести неэффективные права
|-
| '''-s, --skip-base''' || Пропускать файлы, у которых есть только базовые записи
|-
| '''-R, --recursive''' || Отработать рекурсивно
|-
| '''-L, --logical''' || Логический обход, следующий символическим ссылкам
|-
| '''-P, --physical''' || Физический обход, не следующий символическим ссылкам
|-
| '''-t, --tabular''' || Использовать табличный формат вывода
|-
| '''-n, --numeric''' || Выводить ID пользователя/группы вместо имени
|-
| '''-p, --absolute-names''' || Оставлять ведущие '/' в именах путей
|-
| '''-v, --version''' || Вывод версии
|-
| '''-h, --help''' || Вывод справки
|}

== Ссылки ==

* [https://www.opennet.ru/man.shtml?topic=getfacl&category=1&russian=2 OpenNet getfacl мануал] — man-страница getfacl

ACL

2017-05-18T11:38:29Z

Vaal: Новая страница: «'''Access Control List''' или '''ACL''' — список контроля доступа, который определяет, кто или что может…»

'''Access Control List''' или '''ACL''' — список контроля доступа, который определяет, кто или что может получать доступ к конкретному объекту, и какие именно операции разрешено или запрещено этому субъекту проводить над объектом.

Списки контроля доступа являются основой систем с избирательным управлением доступа.

== Введение ==
В типичных ACL каждая запись определяет субъект воздействия и операцию: например, запись ''(Vasya, delete)'' в ACL для файла ''XYZ'' даёт возможность пользователю ''Vasya'' удалить файл ''XYZ''.

В системе с моделью безопасности, основанной на ACL, когда субъект запрашивает выполнение операции над объектом, система сначала проверяет список разрешённых для этого субъекта операций, и только после этого даёт (или не даёт) доступ к запрошенному действию.


При централизованном хранении списков контроля доступа можно говорить о ''матрице доступа'', в которой по осям размещены объекты и субъекты, а в ячейках — соответствующие права. Однако в большом количестве систем списки контроля доступа к объектам хранятся отдельно для каждого объекта, зачастую непосредственно с самим объектом.

Традиционные ACL системы назначают права индивидуальным пользователям, и со временем и ростом числа пользователей в системе списки доступа могут стать громоздкими. Вариантом решения этой проблемы является назначения прав группам пользователей, а не персонально. Другим вариантом решения этой проблемы является «'''Управление доступом на основе ролей'''», где функциональные подмножества прав к ряду объектов объединяются в «роли», и эти роли назначаются пользователям. Однако, в первом варианте группы пользователей также часто называются ролями.

== Файловые системы с ACL ==
В файловых системах для реализации ACL используется идентификатор пользователя процесса (UID в терминах POSIX).

Список доступа представляет собой структуру данных (обычно таблицу), содержащую записи, определяющие права индивидуального пользователя или группы на специальные системные объекты, такие как программы, процессы или файлы. Эти записи также известны как ACE (Access Control Entries) в операционных системах Microsoft Windows и OpenVMS. В операционной системе Linux и Mac OS X большинство файловых систем имеют расширенные атрибуты, выполняющие роль ACL. Каждый объект в системе содержит указатель на свой ACL. Привилегии (или полномочия) определяют специальные права доступа, разрешающие пользователю '''читать''' из (read), '''писать''' в (write), или '''исполнять''' (execute) объект. В некоторых реализациях ACE (Access Control Entries) могут определять право пользователя или группы на изменение ACL объекта.

Концепции ACL в разных операционных системах различаются, несмотря на существующий «стандарт» POSIX. (Проекты безопасности POSIX, .1e и .2c, были отозваны, когда стало ясно что они затрагивают слишком обширную область и работа не может быть завершена, но хорошо проработанные части, определяющие ACL, были широко реализованы и известны как «POSIX ACLs».)

== Сетевые ACL ==
В сетях '''ACL''' представляют список правил, определяющих порты служб или имена доменов, доступных на узле или другом устройстве третьего уровня модели OSI, каждый со списком узлов и/или сетей, которым разрешен доступ к сервису. Сетевые ACL могут быть настроены как на обычном сервере, так и на маршрутизаторе и могут управлять как входящим, так и исходящим трафиком, в качестве межсетевого экрана.

== Ссылки ==
* [http://www.suse.de/~agruen/acl/linux-acls/online/ POSIX Access Control Lists on Linux]
* [http://www.rsbac.org/documentation/rsbac_handbook/security_models#access_control_lists_acl RSBAC Access Control Lists on Linux]
* [http://phpgacl.sourceforge.net/ Generic Access Control Lists for PHP/Perl]
* [http://www.c2.com/cgi/wiki?AccessControlList C2-Wiki Discussion and Relational Implementation]
* [http://searchsecurity.techtarget.com/sDefinition/0,,sid14_gci213757,00.html Information Security Definitions: ACL]
* [http://wiki.kaspersandberg.com/doku.php?id=howtos:acl Easy and detailed ACL howto for linux]
* [http://msdn.microsoft.com/msdnmag/issues/05/03/SecurityBriefs/default.aspx Security Briefs: Access Control List Editing in .NET]
* [http://msdn2.microsoft.com/en-us/library/ms229742.aspx MS Windows .NET ACL Technology]
* [http://wt.xpilot.org/publications/posix.1e/download.html What could have been IEEE 1003.1e/2c]
* [http://web.archive.org/web/20051102080247/http://manuals.info.apple.com/en/File_Services_v10.4.pdf Apple Mac OS X Server version 10.4+ ''File Services Administration'' Manual (see pages 16-26)]
* [http://aclbit.sourceforge.net/ ACLbit — ACL Backup and Inspect Tool for Linux]
* [http://www.u-networks.net/glavnaya/nastrojka-spiskov-dostupa-na-morshrutizatore-cisco/ Настройка и описание ACL на маршрутизаторе Cisco]

Subnetting

2017-05-18T11:18:14Z

Vaal:

== Введение ==

'''Маска подсети''' — битовая маска, определяющая, какая часть IP-адреса узла сети относится к адресу сети, а какая — к адресу самого узла в этой сети (при этом, в отличие от IP-адреса, маска подсети не является частью IP-пакета). Например, узел с IP-адресом 12.34.56.78 и маской подсети 255.255.255.0 находится в сети 12.34.56.0 с длиной префикса 24 бита. В случае адресации IPv6 адрес 2001:0DB8:1:0:6C1F:A78A:3CB5:1ADD с длиной префикса 32 бита (/32) находится в сети 2001:0DB8::/32.

Другой вариант определения — это определение подсети IP-адресов. Например, с помощью маски подсети можно сказать, что один диапазон IP-адресов будет в одной подсети, а другой диапазон соответственно в другой подсети.

Чтобы получить адрес сети, зная IP-адрес и маску подсети, необходимо применить к ним операцию поразрядной конъюнкции (логическое И). Например, в случае более сложной маски (битовые операции в IPv6 выглядят аналогично):

IP-адрес: 11000000 10101000 00000001 00000010 (192.168.1.2)
Маска подсети: 11111111 11111111 11111110 00000000 (255.255.254.0)
Адрес сети: 11000000 10101000 00000000 00000000 (192.168.0.0)

Легенда:
*Часть маски, определяющая адрес сети, состоящая из единиц.
*Адрес сети, который определяется маской подсети.
*Диапазон адресов устройств в этой сети.

Разбиение одной большой сети на несколько маленьких подсетей позволяет упростить маршрутизацию. Например, пусть таблица маршрутизации некоторого маршрутизатора содержит следующую запись:

{| class="standard"
!Сеть назначения
!Маска сети
!Адрес шлюза
|-
|192.168.1.0
|255.255.255.0
|10.20.30.1
|}

Пусть теперь маршрутизатор получает пакет данных с адресом назначения 192.168.1.2. Обрабатывая построчно таблицу маршрутизации, он обнаруживает, что при наложении на адрес 192.168.1.2 маски 255.255.255.0 получается адрес сети 192.168.1.0. В таблице маршрутизации этой сети соответствует шлюз 10.20.30.1, которому и отправляется пакет.

{| class="wikitable sortable"
|-
! IP-адреса !! Биты(Bits) !! Префикс(Prefix) !! Маска подсети(Subnet mask)
|-
| 1 || 0 || /32 || 255.255.255.255
|-
| 2 || 1 || /31 || 255.255.255.254
|-
| 4 || 2 || /30 || 255.255.255.252
|-
| 8 || 3 || /29 || 255.255.255.248
|-
| 16 || 4 || /28 || 255.255.255.240
|-
| 32 || 5 || /27 || 255.255.255.224
|-
| 64 || 6 || /26 || 255.255.255.192
|-
| 128 || 7 || /25 || 255.255.255.128
|-
| 256 || 8 || /24 || 255.255.255.0
|-
| 512 || 9 || /23 || 255.255.254.0
|-
| 1k || 10 || /22 || 255.255.252.0
|-
| 2k || 11 || /21 || 255.255.248.0
|-
| 4k || 12 || /20 || 255.255.240.0
|-
| 8k || 13 || /19 || 255.255.224.0
|-
| 16k || 14 || /18 || 255.255.192.0
|-
| 32k || 15 || /17 || 255.255.128.0
|-
| 64k || 16 || /16 || 255.255.0.0
|-
| 128k || 17 || /15 || 255.254.0.0
|-
| 256k || 18 || /14 || 255.252.0.0
|-
| 512K || 19 || /13 || 255.248.0.0
|-
| 1M || 20 || /12 || 255.240.0.0
|-
| 2M || 21 || /11 || 255.224.0.0
|-
| 4M || 22 || /10 || 255.192.0.0
|-
| 8M || 23 || /9 || 255.128.0.0
|-
| 16M || 24 || /8 || 255.0.0.0
|-
| 32M || 25 || /7 || 254.0.0.0
|-
| 64M || 26 || /6 || 252.0.0.0
|-
| 128M || 27 || /5 || 248.0.0.0
|-
| 256M || 28 || /4 || 240.0.0.0
|-
| 512M || 29 || /3 || 224.0.0.0
|-
| 1024M || 30 || /2 || 192.0.0.0
|-
| 2048M || 31 || /1 || 128.0.0.0
|-
| 4096M || 32 || /0 || 0.0.0.0
|-
|}

== Маски при бесклассовой маршрутизации (CIDR) ==
Маски подсети являются основой метода бесклассовой маршрутизации (CIDR). При этом подходе маску подсети записывают вместе с IP-адресом в формате «''IP-адрес/количество единичных бит в маске''». Число после знака дроби (так называемая ''длина префикса сети'') означает количество единичных разрядов в маске подсети.

Рассмотрим пример записи диапазона IP-адресов в виде 10.96.0.0/11. В этом случае маска подсети будет иметь двоичный вид 11111111 11100000 00000000 00000000, или то же самое в десятичном виде: 255.224.0.0. 11 разрядов IP-адреса отводятся под ''адрес сети'', а остальной 32-11=21 разряд полного адреса (<s>11111111 111</s>00000 00000000 00000000) — под локальный адрес в этой сети. Итого, 10.96.0.0/11 означает диапазон адресов от 10.96.0.0 до 10.127.255.255.

== Диапазоны адресов ==
IP-адрес является массивом бит. Принцип IP-адресации — выделение множества (диапазона, блока, подсети) IP-адресов, в котором некоторые битовые разряды имеют фиксированные значения, а остальные разряды пробегают все возможные значения. Блок адресов задаётся указанием начального адреса и маски подсети. Бесклассовая адресация основывается на переменной длине маски подсети (variable length subnet mask,VLSM), в то время, как в классовой (традиционной) адресации длина маски строго фиксирована 0, 1, 2 или 3 установленными октетами.

Пример подсети 192.0.2.32/27 с применением бесклассовой адресации:
{| border=1 | class="standard" | align="center"
! align="left" | Октеты IP-адреса
| align="center" colspan=8 | 192 || align="center" colspan=8 | 0 || align="center" colspan=8 | 2 || align="center" colspan=8 | 32
|-
! align="left" | Биты IP-адреса
| 1 || 1 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 1 || 0 || 0 || 0 || 1 || 0 || 0 || 0 || 0 || 0
|-
! align="left" | Биты маски подсети
| 1 || 1 || 1 || 1 || 1 || 1 || 1 || 1 || 1 || 1 || 1 || 1 || 1 || 1 || 1 || 1 || 1 || 1 || 1 || 1 || 1 || 1 || 1 || 1 || 1 || 1 || 1 || 0 || 0 || 0 || 0 || 0
|-
! align="left" | Октеты маски подсети
| align="center" colspan=8 | 255 || align="center" colspan=8 | 255 || align="center" colspan=8 | 255 || align="center" colspan=8 | 224
|}
В данном примере видно, что в маске подсети 27 бит слева — единицы. В таком случае говорят о длине префикса подсети в 27 бит и указывают через косую черту (знак ''/'') после базового адреса.

Пример записи IP-адреса 172.16.0.1/12 с применением бесклассовой адресации:
{| border=1 | class="standard" | align="center"
! align="left" | Октеты IP-адреса
| align="center" colspan=8 | 172 || align="center" colspan=8 | 16 || align="center" colspan=8 | 0 || align="center" colspan=8 | 1
|-
! align="left" | Биты IP-адреса
| 1 || 0 || 1 || 0 || 1 || 1 || 0 || 0 || 0 || 0 || 0 || 1 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 1
|-
! align="left" | Биты маски подсети
| 1 || 1 || 1 || 1 || 1 || 1 || 1 || 1 || 1 || 1 || 1 || 1 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0 || 0
|-
! align="left" | Октеты маски подсети
| align="center" colspan=8 | 255
| align="center" colspan=8 | 240 || align="center" colspan=8 | 0 || align="center" colspan=8 | 0
|}

Множество всех адресов соответствует нулевой маске подсети и обозначается /0, а конкретный адрес IPv4 — маске подсети с длиной префикса в 32 бита, обозначаемой /32.

Для упрощения таблиц маршрутизации можно объединять блоки адресов, указывая один большой блок вместо ряда мелких. Например, 4 смежные сети класса C (4 × 255 адресов, маска 255.255.255.0 или /24) могут быть объединены, с точки зрения далёких от них маршрутизаторов, в одну сеть /22. И напротив, сети можно разбивать на более мелкие подсети, и так далее.

Стандартом принята маска в виде непрерывной последовательности единиц и непрерывной последовательности нулей. Только для таких масок получающиеся множества IP-адресов будут смежными. Однако, также широко распространены обратные маски (invers mask, wildcard mask), которые не обязаны содержать подряд идущие единицы или нули. Обратная маска используется для формирования правил ''ACL''.



{| class="wikitable"
|+ IPv4 CIDR
!IP/маска
! До последнего IP
в подсети
!Маска
!Количество адресов
!Количество хостов
!Класс
|-
|a.b.c.d'''/32'''
| +0.0.0.0
|255.255.255.255
|1
|1*
|1/256 C
|-
|a.b.c.d'''/31'''
| +0.0.0.1
|255.255.255.254
|2
|2*
|1/128 C
|-
|a.b.c.d'''/30'''
| +0.0.0.3
|255.255.255.252
|4
|2
|1/64 C
|-
|a.b.c.d'''/29'''
| +0.0.0.7
|255.255.255.248
|8
|6
|1/32 C
|-
|a.b.c.d'''/28'''
| +0.0.0.15
|255.255.255.240
|16
|14
|1/16 C
|-
|a.b.c.d'''/27'''
| +0.0.0.31
|255.255.255.224
|32
|30
|1/8 C
|-
|a.b.c.d'''/26'''
| +0.0.0.63
|255.255.255.192
|64
|62
|1/4 C
|-
|a.b.c.d'''/25'''
| +0.0.0.127
|255.255.255.128
|128
|126
|1/2 C
|-
|a.b.c.0'''/24'''
| +0.0.0.255
|255.255.255.000
|256
|254
|1 C
|-
|a.b.c.0'''/23'''
| +0.0.1.255
|255.255.254.000
|512
|510
|2 C
|-
|a.b.c.0'''/22'''
| +0.0.3.255
|255.255.252.000
|1024
|1022
|4 C
|-
|a.b.c.0'''/21'''
| +0.0.7.255
|255.255.248.000
|2048
|2046
|8 C
|-
|a.b.c.0'''/20'''
| +0.0.15.255
|255.255.240.000
|4096
|4094
|16 C
|-
|a.b.c.0'''/19'''
| +0.0.31.255
|255.255.224.000
|8192
|8190
|32 C
|-
|a.b.c.0'''/18'''
| +0.0.63.255
|255.255.192.000
|16 384
|16 382
|64 C
|-
|a.b.c.0'''/17'''
| +0.0.127.255
|255.255.128.000
|32 768
|32 766
|128 C
|-
|a.b.0.0'''/16'''
| +0.0.255.255
|255.255.000.000
|65 536
|65 536
|256 C = 1 B
|-
|a.b.0.0'''/15'''
| +0.1.255.255
|255.254.000.000
|131 072
|131 070
|2 B
|-
|a.b.0.0'''/14'''
| +0.3.255.255
|255.252.000.000
|262 144
|262 142
|4 B
|-
|a.b.0.0'''/13'''
| +0.7.255.255
|255.248.000.000
|524 288
|524 286
|8 B
|-
|a.b.0.0'''/12'''
| +0.15.255.255
|255.240.000.000
|1 048 576
|1 048 574
|16 B
|-
|a.b.0.0'''/11'''
| +0.31.255.255
|255.224.000.000
|2 097 152
|2 097 150
|32 B
|-
|a.b.0.0'''/10'''
| +0.63.255.255
|255.192.000.000
|4 194 304
|4 194 302
|64 B
|-
|a.b.0.0'''/9'''
| +0.127.255.255
|255.128.000.000
|8 388 608
|8 388 606
|128 B
|-
|a.0.0.0'''/8'''
| +0.255.255.255
|255.000.000.000
|16 777 216
|16 777 214
|256 B = 1 A
|-
|a.0.0.0'''/7'''
| +1.255.255.255
|254.000.000.000
|33 554 432
|33 554 430
|2 A
|-
|a.0.0.0'''/6'''
| +3.255.255.255
|252.000.000.000
|67 108 864
|67 108 862
|4 A
|-
|a.0.0.0'''/5'''
| +7.255.255.255
|248.000.000.000
|134 217 728
|134 217 726
|8 A
|-
|a.0.0.0'''/4'''
| +15.255.255.255
|240.000.000.000
|268 435 456
|268 435 454
|16 A
|-
|a.0.0.0'''/3'''
| +31.255.255.255
|224.000.000.000
|536 870 912
|536 870 910
|32 A
|-
|a.0.0.0'''/2'''
| +63.255.255.255
|192.000.000.000
|1 073 741 824
|1 073 741 822
|64 A
|-
|a.0.0.0'''/1'''
| +127.255.255.255
|128.000.000.000
|2 147 483 648
|2 147 483 646
|128 A
|-
|0.0.0.0'''/0'''
| +255.255.255.255
|000.000.000.000
|4 294 967 296
|4 294 967 294
|256 A
|}

<nowiki>*</nowiki>Чтобы в сетях с такой размерностью маски возможно было разместить хосты, отступают от правил принятых для работы в остальных сетях.

Возможных узлов подсети меньше количества адресов на два: начальный адрес сети резервируется для идентификации подсети, последний — в качестве широковещательного адреса (возможны исключения в виде адресации в IPv4 сетей /32 и /31).

Iptables

2017-05-15T07:45:17Z

Vaal:

[[File:Iptablesfb.png|thumb|iptables]]
'''iptables''' — утилита командной строки, является стандартным интерфейсом управления работой межсетевого экрана(брандмауэра) '''netfilter''' для ядер Linux версий 2.4, 2.6, 3.x, 4.x . Для использования утилиты iptables требуются привилегии суперпользователя(root).

Иногда под словом iptables имеется в виду и сам межсетевой экран netfilter.

== История ==
Изначально разработка netfilter и iptables шла совместно, поэтому в ранней истории этих проектов есть много общего. Подробности см. в статье про netfilter.

Предшественниками iptables были проекты ipchains (применялась для администрирования фаервола ядра Linux версии 2.2) и ipfwadm(аналогично для ядер Linux версий 2.0). Последний был основан на BSD-утилите ipfw.

iptables сохраняет идеологию, ведущую начало от ipfwadm: функционирование фаервола определяется набором правил, каждое из которых состоит из критерия и действия, применяемого к пакетам, подпадающим под этот критерий. В ipchains появилась концепция ''цепочек'' — независимых списков правил. Были введены отдельные цепочки для фильтрации входящих (INPUT), исходящих (OUTPUT) и транзитных (FORWARD) пакетов. В продолжении этой идеи, в iptables появились ''таблицы'' — независимые группы цепочек. Каждая таблица решала свою задачу — цепочки таблицы filter отвечали за фильтрацию, цепочки таблицы nat — за преобразование сетевых адресов ('''NAT'''), к задачам таблицы mangle относились прочие модификации заголовков пакетов (например, изменение Time to live('''TTL''') или Тип обслуживания('''TOS''')). Кроме того, была слегка изменена логика работы цепочек: в ipchains все входящие пакеты, включая транзитные, проходили цепочку INPUT. В iptables через INPUT проходят только пакеты, адресованные самому хосту.

Такое разделение функциональности позволило iptables при обработке отдельных пакетов использовать информацию о соединениях в целом (ранее это было возможно только для NAT). В этом iptables значительно превосходит ipchains, так iptables может отслеживать состояние соединения и перенаправлять, изменять или отфильтровывать пакеты, основываясь не только на данных из их заголовков (источник, получатель) или содержимом пакетов, но и на основании данных о соединении. Такая возможность фаервола называется stateful-фильтрацией, в отличие от реализованной в ipchains примитивной stateless-фильтрации (подробнее о видах фильтрации см. статью о фаерволах). Можно сказать, что iptables анализирует не только передаваемые данные, но и контекст их передачи, в отличие от ipchains, и поэтому может принимать более обоснованные решения о судьбе каждого конкретного пакета. Более подробно о stateful-фильтрации в netfilter/iptables.

В будущем, разработчики netfilter планируют заменить iptables на '''nftables''' — инструмент нового поколения, пока находящийся в ранней стадии разработки[http://www.opennet.ru/opennews/art.shtml?num=20843 Разработчики Netfilter представили замену iptables].

== Архитектура ==

=== Основные понятия ===

Ключевыми понятиями iptables являются:
* '''Правило''' — состоит из ''критерия'', ''действия'' и ''счетчика''. Если пакет соответствует критерию, к нему применяется действие, и он учитывается счетчиком. Критерия может и не быть — тогда неявно предполагается критерий «все пакеты». Указывать действие тоже не обязательно — в отсутствие действия правило будет работать только как счетчик.
** '''Критерий''' — логическое выражение, анализирующее свойства пакета и/или соединения и определяющее, подпадает ли данный конкретный пакет под действие текущего правила.
** '''Действие''' — описание действия, которое нужно проделать с пакетом и/или соединением в том случае, если они подпадают под критерий этого правила. О действиях более подробно будет рассказано ниже.
** '''Счетчик''' — компонент правила, обеспечивающий учет количества пакетов, которые попали под критерий данного правила. Также счетчик учитывает суммарный объем таких пакетов в байтах.
* '''Цепочка''' — упорядоченная последовательность правил. Цепочки можно разделить на ''пользовательские'' и ''базовые''.
** '''Базовая цепочка''' — цепочка, создаваемая по умолчанию при инициализации таблицы. Каждый пакет, в зависимости от того, предназначен ли он самому хосту, сгенерирован им или является транзитным, должен пройти положенный ему набор базовых цепочек различных таблиц. Схема следования пакетов приведена на рисунке. Кроме того, базовая цепочка отличается от пользовательской наличием «действия по умолчанию» (default policy). Это действие применяется к тем пакетам, которые не были обработаны другими правилами этой цепочки и вызванных из нее цепочек (см. переходы). Имена базовых цепочек всегда записываются в верхнем регистре (PREROUTING, INPUT, FORWARD, OUTPUT, POSTROUTING).
** '''Пользовательская цепочка''' — цепочка, созданная пользователем. Может использоваться только в пределах своей таблицы. Рекомендуется не использовать для таких цепочек имена в верхнем регистре, чтобы избежать путаницы с базовыми цепочками и встроенными действиями.
* '''Таблица''' — совокупность ''базовых'' и ''пользовательских'' цепочек, объединенных общим функциональным назначением. Имена таблиц (как и модулей критериев) записываются в нижнем регистре, так как в принципе не могут конфликтовать с именами пользовательских цепочек. При вызове команды iptables таблица указывается в формате <tt>-t имя_таблицы</tt>. При отсутствии явного указания, используется таблица filter. Более подробно таблицы будут рассмотрены ниже.

=== Принцип работы ===

Все пакеты пропускаются через определенные для них последовательности цепочек (см. рис.). При прохождении пакетом цепочки, к нему последовательно применяются все правила этой цепочки в порядке их следования. Под применением правила понимается: во-первых, проверка пакета на соответствие критерию, и во-вторых, если пакет этому критерию соответствует, применение к нему указанного действия. Под действием может подразумеваться как элементарная операция (встроенное действие, например, ACCEPT, MARK), так и переход в одну из пользовательских цепочек. В свою очередь, действия могут быть как терминальными, то есть прекращающими обработку пакета в рамках данной базовой цепочки (например, ACCEPT, REJECT), так и нетерминальными, то есть не прерывающими процесса обработки пакета (MARK, TOS). Если пакет прошел через всю базовую цепочку и к нему так и не было применено ни одного терминального действия, к нему применяется действие по умолчанию для данной цепочки (обязательно терминальное). Например,
<source lang="bash">
iptables -F # Очищаем все цепочки таблицы filter
iptables -A INPUT -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT # Ко всем пакетам, которые относятся к уже установленным
# соединениям, применяем терминальное действие ACCEPT — пропустить
iptables -P INPUT DROP # В качестве действия по умолчанию устанавливаем DROP — блокирование пакета
iptables -P OUTPUT ACCEPT # Разрешаем все исходящие пакеты
</source>
Теперь цепочка INPUT таблицы filter содержит единственное правило, которое пропускает все пакеты, относящиеся к уже установленным соединениям. Ко всем остальным входящим пакетам будет применено действие по умолчанию — DROP. Цепочка же OUTPUT вообще не содержит правил, поэтому ко всем исходящим пакетам будет применяться действие по умолчанию ACCEPT. Таким образом хост, настроенный согласно этому примеру и подключенный к Интернету, будет недоступен извне (все попытки установить соединение снаружи блокируются), однако с самого хоста доступ к Интернету будет свободный (исходящие пакеты разрешены, а ответы на них уже относятся к установленным соединениям).

=== Основные компоненты ===

==== netfilter ====


[[Файл:Netfilter-components-ru.svg.png|600px|thumb|Взаимосвязь основных компонентов netfilter и conntrack]]


Компонент ядра '''Linux''', обеспечивающий фильтрацию и модификацию трафика. Собственно, именно он и является фаерволом. В состав netfilter входят следующие модули:
* '''ip_tables''' — фаервол для протокола IPv4. Обеспечивает фильтрацию пакетов, модификацию их заголовков и NAT.
* '''ip6_tables''' — фаервол для протокола IPv6. Обеспечивает фильтрацию пакетов и модификацию их заголовков.
* '''arp_tables''' — фаервол для протоколов ARP и RARP. Обеспечивает фильтрацию и модификацию пакетов.
* '''x_tables''' — бэкенд для ip_tables, ip6_tables и arp_tables. В этом модуле определены основные операции для работы с фаерволами «таблично-цепочечной» структуры и их компонентами.
* '''ebtables''' — Ethernet-фаервол (префикс eb от Ethernet Bridge). В отличие от трех перечисленных выше фаерволов, работающих с протоколами сетевого и более высоких уровней, ebtables работает на канальном уровне, выполняя фильтрацию и модификацию ethernet-кадров, проходящих через сетевые мосты, если таковые имеются на хосте.

Принципы работы с ip_tables и ip6_tables практически идентичны, с тем небольшим отличием, что в ip6_tables отсутствует таблица nat и соответствующие действия. В то же время, принципы построения правил в arp_tables и ebtables несколько иные. В частности, arp_tables и ebtables имеют четыре базовых действия — ACCEPT (пропустить), DROP (заблокировать), CONTINUE (продолжить обработку в данной цепочке) и RETURN (прекратить обработку в данной цепочке, вернуть в цепочку уровнем выше). Эти действия могут использоваться отдельно, либо применяться к пакетам после выполнения какого-либо преобразующего действия (например, маркировки). Таким образом, после применения преобразования пакет может быть, скажем, немедленно пропущен фаерволом (ACCEPT), либо будет вынужден проследовать через последующие правила (CONTINUE). Этим arptables и ebtables отличаются от ip_tables и ip6_tables — в последних существует четкое разделение действий на терминальные и нетерминальные, которое нельзя изменить при составлении набора правил, а чтобы, например, пропустить пакет после некоторого нетерминального преобразования, необходимо добавлять дополнительное правило («<tt>iptables ... -j MARK ...; iptables ... -j ACCEPT</tt>» вместо «<tt>ebtables ... -j mark ... --mark-target ACCEPT</tt>»). Также, система conntrack не производит отслеживание соединений для ARP/RARP и Ethernet, поэтому возможности stateful-фильтрации в arp_tables и ebtables отсутствуют (нет критерия conntrack и таблицы raw).

В данной статье рассматриваются только аспекты работы с ip_tables и ip6_tables. В их задачи входит:
* Классификация пакетов на основе различных критериев. В качестве критерия могут выступать, например, IP-адреса источника и/или назначения, состояние соединения (новое/уже установленное), порты TCP/IP источника и/или назначения (для протоколов транспортного уровня, имеющих порты), вспомогательные значения в заголовках пакетов (скажем, длина пакета,Type of Service(TOS), Time to live(TTL)) и т. п. Результаты этой классификации используются при решении других задач из данного списка.
* Фильтрация входящих (INPUT), исходящих (OUTPUT) и транзитных (FORWARD) пакетов, сводящуюся либо к их пропусканию (ACCEPT), либо к блокированию (DROP или REJECT). Также поддерживаются дополнительные возможности, например, блокирование попыток сканирования портов (DELUDE и CHAOS), эффективное противодействие (D)DoS-атакам (TARPIT).
* Модификация заголовков пакетов и связанной информации. К этому классу задач можно отнести:
** Трансляцию сетевых адресов (NAT), включая маскарадинг(SNAT или MASQUERADE), «проброс» адресов и портов (DNAT) и даже целых подсетей (NETMAP). Эта задача касается только модуля ip_tables. Модуль ip6_tables не производит трансляции адресов.
** Изменение различных вспомогательных величин в заголовках пакетов, например, TOS, TTL, TCP MSS.
** Установку и изменение маркировки пакетов и соединений. Впоследствии эта маркировка может быть использована системой iproute2 для маршрутизации и шейпинга трафика.
* Учет количества обработанных пакетов и их суммарного размера при помощи счетчиков.
* Занесение информации о пакетах в системный журнал syslog (LOG и LOGMARK).
* Передача на обработку userspace-демонам пакетов целиком (NFQUEUE) либо информации о них (NFLOG), что позволяет решать самый широкий круг задач по фильтрации, модификации и учету трафика.
* Внутренние задачи, связанные с обеспечением работы критериев и действий netfilter. Например, сопровождение списков IP-адресов для критериев recent и hashlimit.

==== iptables ====

Userspace-утилита, через которую системный администратор может управлять IPv4-фаерволом (ip tables). К ее задачам относятся:
* Создание и удаление пользовательских цепочек.
* Установка действий по умолчанию для базовых цепочек.
* Добавление и удаление правил.
* Установка и обнуление счетчиков пакетов и байт.
* Просмотр цепочек и правил, а также значений счетчиков.
* Проверка корректности задания параметров, определяющих работу критериев и действий.
* Вывод справки по использованию критериев (<tt>iptables -m ''критерий'' -h</tt>) и действий (<tt>iptables -j ''действие'' -h</tt>).
Также в комплект поставки вместе с iptables обычно входят вспомогательные утилиты, обеспечивающие сохранение (iptables-save) и последующее восстановление (iptables-restore) состояния фаервола, его инициализацию при запуске системы (init-скрипт) и т. п.

Сегментом фаервола, отвечающим за фильтрацию IPv6-пакетов (ip6 tables), управляет утилита ip6tables. Так как обычно она поставляется вместе с iptables, имеет похожий синтаксис и выполняет схожие задачи, под термином «iptables» часто подразумевают сразу обе эти утилиты.

Также в рамках данного проекта разрабатываются два набора библиотек:
* '''libiptc''' — содержит функции, осуществляющие вышеперечисленные операции по управлению цепочками и правилами. Именно с этими функциями и работают утилиты iptables (библиотека libip4tc) и ip6tables (библиотека libip6tc). Приложения, использующие эти библиотеки, могут обращаться к netfilter напрямую, минуя вызов утилит iptables и ip6tables. В качестве примера такого приложения можно назвать Perl-модуль [http://search.cpan.org/~hawk/IPTables-libiptc-0.18/lib/IPTables/libiptc.pm IPTables::libiptc, предоставляющий доступ к функциям этих библиотек из Perl-скриптов.
* '''libipq''' — содержит функции, позволяющие пользовательским приложениям принимать IP-пакеты на обработку. Отправка со стороны ядра выполняется через модуль ip queue (ip6_queue для IPv6), что соответствует действию QUEUE. В настоящее время этот механизм [http://netfilter.org/projects/libnetfilter_queue/index.html объявлен устаревшим], и вместо него рекомендуется использовать действие NFQUEUE, работа которого реализуется через модуль ядра nfnetlink_queue и библиотеку libnetfilter_queue.

==== conntrack ====

Компонент netfilter, обеспечивающий отслеживание состояния соединений и классификацию пакетов с точки зрения принадлежности к соединениям, что позволяет netfilter осуществлять полноценную stateful-фильтрацию трафика. Как и netfilter, система conntrack является частью ядра '''Linux'''. К его задачам относятся:
* Отслеживание состояний отдельных соединений с тем, чтобы классифицировать каждый пакет либо как относящийся к уже установленному соединению, либо как открывающий новое соединение. При этом понятие "состояние соединения" искусственно вводится для протоколов, в которых оно изначально отсутствует (UDP, ICMP). При работе же с протоколами, поддерживающими состояния (например, TCP), conntrack активно использует эту возможность, тесно взаимодействуя с базовой сетевой подсистемой ядра Linux.
* Отслеживание связанных соединений, например, ICMP-ответов на TCP и UDP-пакеты. Более сложный вариант — протоколы, использующие несколько соединений в одной сессии, например, FTP. Для правильной обработки таких протоколов conntrack использует специальные модули (conntrack helpers), которые анализируют трафик и «выхватывают» информацию протокола о новых соединениях (например, порт, на который оно будет открыто), что позволяет обеспечить их корректную фильтрацию, маршрутизацию, шейпинг и пропускание через NAT.

Более подробно о возможностях системы conntrack и их использовании при работе с iptables/netfilter.

В состав conntrack входят следующие компоненты:
* Главный модуль nf_conntrack. Реализует базовую функциональность отслеживания соединений, интерфейсы для работы с модулями расширений, а также механизмы отслеживания протоколов TCP и UDP.
* Трекеры протоколов сетевого уровня: nf_conntrack_ipv4 и nf_conntrack_ipv6. Реализуют операции, специфичные для «своих» протоколов (IPv4 и IPv6 соответственно), а также механизмы отслеживания соответствующих протоколов управляющих сообщений (ICMP и ICMPv6 соответственно).
* Трекеры протоколов транспортного уровня (кроме TCP и UDP, реализованных в главном модуле): nf_conntrack_proto_sctp (SCTP), nf_conntrack_proto_dccp (DCCP), nf_conntrack_proto_gre (GRE), nf_conntrack_proto_udplite (UDP Lite).
* Вспомогательные модули (helpers), обеспечивающие отслеживание протоколов прикладного и сеансового уровней: nf_conntrack_ftp, nf_conntrack_irc, nf_conntrack_pptp, nf_conntrack_netbios_ns и т. п. Требуются далеко не для всех протоколов, а только для тех, отслеживание которых требует знания специфики протокола. Например, неоднократно упоминающийся в этой статье протокол FTP}} использует в одном сеансе два соединения (управляющее соединение и соединение передачи данных), и чтобы корректно отследить соединение передачи данных, необходимо анализировать трафик управляющего соединения и выделять в нем информацию, касающуюся открытия соединения данных.
* Модуль nf_nat. Реализует базовую функциональность трансляции сетевых адресов и портов с учетом информации о соединениях. Также этот модуль содержит механизмы трансляции для протоколов IPv4, TCP, UDP и ICMP (IPv6 и ICMPv6 не поддерживаются NAT-подсистемой conntrack).
* NAT-трекеры протоколов транспортного уровня: nf_nat_proto_sctp, nf_nat_proto_dccp, nf_nat_proto_gre, nf_nat_proto_udplite.
* Вспомогательные модули NAT для протоколов прикладного и сеансового уровней: nf_nat_ftp, nf_nat_irc, nf_nat_pptp и т. п.
* Модуль взаимодействия с userspace через протокол nfnetlink (см. следующий раздел) nf_conntrack_netlink, которому соответствует userspace-библиотека libnetfilter_conntrack.
* Кроме того, к conntrack можно условно отнести и модули netfilter, обеспечивающие взаимодействие этих двух подсистем: критерий conntrack (xt_conntrack), действия NOTRACK и CT (xt_NOTRACK и xt_CT), практически все действия таблицы nat, а также соответствующие модули (библиотеки iptables/ip6tables): libxt_conntrack, libxt_NOTRACK, libxt_CT и т. п.

Для взаимодействия с системой conntrack из userspace разработан комплект [http://conntrack-tools.netfilter.org/ conntrack-tools], содержащий две утилиты:
* '''conntrack''' — инструмент, позволяющий системному администратору наблюдать таблицы состояний соединений и взаимодействовать с ними: очищать таблицы целиком, удалять отдельные записи, маркировать соединения вручную (аналог действия CONNMARK), устанавливать тайм-ауты соединений. Поддерживается фильтрация вывода (например, на основании адресов и/или портов источника и/или назначения), а также вывод в различных форматах, включая XML. Кроме того, данная утилита позволяет отслеживать в реальном времени события системы conntrack, например, открытие новых соединений или изменение состояния существующих.
* '''conntrackd''' — демон, обеспечивающий синхронизацию таблиц состояний с другими хостами, что в сочетании с возможностями демона keepalived позволяет создавать фаерволы на кластерах высокой доступности (High Availability) — при выходе из строя одного из хостов кластера его соединения будут «подхвачены» другими хостами кластера и корректно обработаны с учетом состояний. Также conntrackd можно использовать просто для удаленного сбора статистики по соединениям.

Взаимодействие conntrack с этими программами производится посредством интерфейса nfnetlink, который будет рассмотрен в следующем разделе.

==== nfnetlink ====

Интерфейс, позволяющий различным userspace-приложениям взаимодействовать с netfilter и conntrack. Со стороны userspace он обеспечивается набором библиотек libnfnetlink. Ключевые библиотеки из этого набора:
* '''libnetfilter_conntrack''' (ранее libnfnetlink_conntrack и libctnetlink) — обеспечивает взаимодействие приложений с системой conntrack. В качестве примеров приложений, использующих эту библиотеку, можно упомянуть:
** Описанные выше программы '''conntrack''' и '''conntrackd''' из комплекта conntrack-tools.
** '''iptstate''' — в какой-то мере аналог утилиты conntrack, хотя и не имеющий таких богатых возможностей. Предназначена для непрерывного вывода таблицы состояний соединений с периодическим обновлением, в стиле широко известной утилиты top. Поддерживает различные виды сортировки (по адресам/портам источника/назначения, тайм-ауту, счетчикам и т. п.). Позволяет удалять записи из таблицы состояний. Не поддерживает работу с таблицей ожидаемых (expected) соединений.
* '''libnetfilter_queue''' (ранее libnfnetlink_queue) — отвечает за передачу пакетов демонам на предмет анализа. По результатам этого анализа пакет может быть заблокирован или пропущен. При пропускании пакета возможна установка или изменение его маркировки (nfmark). Идеологическим предшественником libnetfilter_queue была ныне устаревшая библиотека libipq. В качестве примеров приложений, использующих libnetfilter_queue, можно упомянуть:
** '''nufw''' — фаервол, выполняющий фильтрацию трафика на основе авторизации пользователей. Позволяет устанавливать ограничения на доступ к сетям, находящимся за фаерволом, для отдельных пользователей. Авторизация пользователей на фаерволе обеспечивается отдельным демоном nuauth. Например, в случае, если клиенты используют Linux, авторизация может выполняться совершенно прозрачно, благодаря возможностям PAM(модуль pam_nufw) в момент входа пользователя в систему. Особенно удобны подобные системы в корпоративных сетях, где используются системы централизованного управления аккаунтами пользователей (nufw/nuauth поддерживает LDAP и winbind).
** '''l7-filter-userspace''' — демон, позволяющий определить протокол 7-го (прикладного) уровня модели OSI, которому принадлежит полученный пакет, на основании анализа его содержимого при помощи регулярных выражений. Результат анализа возвращает в маркировке пакета. Полезен при фильтрации и шейпинге трафика протоколов, не имеющих фиксированных номеров портов для соединений данных, например, BitTorrent. Впрочем, в настоящее время существуют и альтернативные решения — P2P-протоколы можно выделять при помощи критерия ipp2p (из набора xtables-addons), а вспомогательные соединения в известных системе conntrack протоколах (FTP, IRC, SIP) можно выделять при помощи критерия helper и маркировки соединений.
** '''iplist''' — userspace-альтернатива ipset. Как и ipset, позволяет считывать большие списки IP-адресов и проверять пакеты на предмет нахождения адреса их источника/назначения в данном списке. В зависимости от результата проверки, пакет может быть пропущен или заблокирован, либо промаркирован соответствующим образом. Разумеется, ipset, работая на уровне ядра, обеспечивает более высокую скорость проверки, а также поддерживает дополнительные возможности, например, динамическое изменение списков при помощи действия SET (добавление и удаление записей), сохранение дополнительной информации (номера портов, MAC-адреса, тайм-ауты записей). Несмотря на то, что в настоящий момент ipset пока что не принят в ядро, современные дистрибутивы ipset позволяет произвести сборку и установку необходимых компонентов без необходимости наложения патчей на ядро и iptables, благодаря возможностям подгружаемых модулей (LKM) ядра Linux. Поэтому, с учетом вышесказанного, необходимость в iplist в настоящее время сомнительна.
* '''libnetfilter_log''' (ранее libnfnetlink_log) — предоставляет демонам интерфейс для получения служебной информации о пакетах на предмет регистрации и учета трафика. В настоящее время известен только один проект, использующий данную библиотеку — '''ulogd2''' ([netfilter] userspace logging daemon, версия 2). Данный проект находится пока в бета-стадии разработки. Надо заметить, что ulogd2 может получать информацию не только через libnetfilter_log (действие NFLOG), но и через классический механизм libipulog (действие ULOG), а также через libnetfilter_conntrack (данный метод позволяет получать информацию не об отдельных пакетах, а о соединениях в целом).

Со стороны ядра взаимодействие обеспечивается базовым модулем nfnetlink и «специализированными» модулями nf_conntrack_netlink, nfnetlink_queue и nfnetlink_log соответственно.

Кроме того, такие программы, как nfnl_osf (передает ядру список сигнатур для критерия детекции операционной системы osf) и ipset начиная с версии 5 (см. ниже) также используют для коммуникаций ядро-userspace интерфейс nfnetlink, но эти задачи являются узкоспециализированными и поэтому реализованы без использования специальных библиотек и модулей ядра.

==== ipset ====

Представляет собой набор инструментов, позволяющий работать с большими списками (sets) IP-адресов и/или портов. Поддерживается возможность динамического обновления списков при прохождении пакетов через правила netfilter.

В версии ipset 4 и более ранних поддерживалась работа только с семейством адресов IPv4, однако начиная с пятой версии реализована также и поддержка IPv6.

Стоит отметить, что долгое время проект ipset существовал вне основной ветки развития ядра Linux. В частности, в четвертой версии ipset «ядерные» компоненты приходилось собирать отдельно, используя заголовочные файлы текущего ядра. Однако, после выхода пятой версии, в которой были учтены все предыдущие замечания, началась работа по включению ipset в основную ветку. Она [http://www.spinics.net/lists/netfilter-devel/msg17027.html завершилась успехом]: поддержка ipset присутствует в Linux начиная с 2.6.39. В ходе этих работ протокол взаимодействия ядерной и userspace-частей ipset подвергся значительной переработке, и окончательная версия [http://git.netfilter.org/cgi-bin/gitweb.cgi?p=ipset.git;a=commit;h=d6ee5bb4e5346b84efa33858091ba4add2b26de2 получила] номер 6.0. Таким образом, в современных ядрах поддержка ipset присутствует штатно, а пользователи более старых ядер могут воспользоваться реализациями ipset версий 4 и 5, включенными в набор [http://xtables-addons.sourceforge.net/ xtables-addons].

ipset состоит из следующих элементов:
* Модуль ядра ip_set, обеспечивающий базовый инструментарий работы со списками записей, который используется модулями расширений.
* Модули расширений, определяющие конкретные структуры записей и методы работы с ними, например, ip_set_hash_ip (тип данных hash:ip), ip_set_bitmap_port (тип данных bitmap:port) и т. д.
* Userspace-утилита ipset, позволяющая выполнять различные операции со списками и записями в них:
** Создание, удаление, переименование, вывод, очистка списков.
** Добавление и удаление записей из списков, проверка наличия записи в списке.
** Вывод справочной информации по работе со списками различного типа.
* Модули расширений для утилиты ipset, соответствующие модулям расширений в ядре, например, ipset_hash_ip (тип данных hash:ip), ipset_bitmap_port (тип данных bitmap:port) и т. д. Каждый такой модуль отвечает за обеспечение нтерфейса между «своим» модулем ядра и конечным пользователем, в частности, проверку корректности вводимых и форматирование выводимых данных, а также вывод справочной информации по допустимым командам и параметрам. В ранних версиях ipset (до 4 включительно) такие модули выделялись в виде подгружаемых библиотек, однако в современных версиях ipset они статически включаются в основной бинарник, поэтому разделение существует лишь в исходном коде.
* Модуль netfilter xt_set (критерий set и действие SET), а также соответствующие модули (библиотеки) iptables (libxt_set и libxt_SET). Критерий set позволяет проверять различные параметры пакета (IP/MAC-адреса, TCP/UDP-порты источника и/или получателя) на предмет нахождения или отсутствия в списке. Действие SET позволяет добавлять или удалять записи из списка на основании указанных параметров пакета. 

ipset поддерживает следующие типы данных (в скобках приведены названия согласно терминологии устаревшей версии ipset 4):
* '''bitmap:ip''' (ipmap) — полный перечень IP-адресов.
* '''bitmap:ip,mac''' (macipmap) — полный перечень IP-адресов, причем вместе с каждым IP-адресом может быть сохранен MAC-адрес.
* '''bitmap:port''' (portmap) — полный перечень портов.
* '''hash:ip''' (iphash) — выборочный перечень IP-адресов (либо IP-подсетей с одинаковой маской).
* '''hash:net''' (nethash) — выборочный перечень IP-подсетей (блоков IP-адресов). В отличие от hash:ip, в одном списке могут присутствовать подсети с различными масками.
* '''hash:ip,port''' (ipporthash) — выборочный перечень IP-адресов, причем с каждым адресом может быть сохранен порт. В версии ipset 4 и более ранних существует ограничение: адреса в пределах одного перечня должны принадлежать одному блоку /16 (/255.255.0.0, максимум 65536 адресов). Начиная с версии ipset 5, для каждого номера порта можно также сохранять идентификатор протокола транспортного уровня.
* '''hash:ip,port,ip''' (ipportiphash) — выборочный перечень IP-адресов, причем с каждым адресом может быть сохранен порт и еще один IP-адрес. В версии ipset 4 и более ранних ограничение на «первичные» адреса (первые в тройке адрес-порт-адрес) такое же, как и для ipporthash. Начиная с версии ipset 5, для каждого номера порта можно также сохранять идентификатор протокола транспортного уровня.
* '''hash:ip,port,net''' (ipportnethash) — выборочный перечень IP-адресов, причем с каждым адресом может быть сохранен порт и IP-подсеть. В версии ipset 4 и более ранних ограничение на «первичные» адреса такое же, как и у типа ipporthash. Начиная с версии ipset 5, для каждого номера порта можно также сохранять идентификатор протокола транспортного уровня.
* '''list:set''' (setlist) — список списков. Может содержать списки любого перечисленного здесь типа, кроме list:set. При обращении к такому объекту из netfilter, включенные в него списки рассматриваются как один большой список. Поиск записей (критерий set) производится по всем вложенным спискам соответствующего типа. При добавлении записей (действие SET), вложенные списки поочередно проверяются (согласно порядку их перечисления) на соответствие типа и наличие свободного места, и запись добавляется в первый же подходящий. В то же время, при обращении к такому списку через утилиту ipset, он рассматривается именно как совокупность элементов-списков, что позволяет добавлять, удалять и проверять наличие именно вложенных списков, но не их элементов.
* '''hash:net,iface''' — выборочный перечень IP-подсетей, причем с каждой подсетью может быть сохранено название сетевого интерфейса. Появился в версии ipset 6.7 (входит в ядро Linux 3.1), ранние версии ipset не имеют подобных возможностей. Существует ограничение: нельзя сохранять более 64 имен интерфейсов с одним и тем же адресом подсети. Этот тип данных удобен при наличии в системе большого количества сетевых интерфейсов (например, сотен VLAN-интерфейсов).

В четвертой версии дополнительно присутствовали два типа списков, упраздненные в более поздних версиях:
* '''iptree''' — выборочный перечень IP-адресов, причем с каждым адресом может быть сохранено значение тайм-аута в секундах. По истечении тайм-аута адрес удаляется из списка. Чтобы активировать возможность использование тайм-аутов для определенного списка, нужно при его создании задать тайм-аут по умолчанию (опция <tt>--timeout</tt>). Начиная с версии ipset 5, данный тип не поддерживается, при попытке его использования автоматически заменяется на hash:ip. Заметим, что начиная с пятой версии тайм-ауты реализованы для всех поддерживаемых типов данных.
* '''iptreemap''' — гибридный перечень, позволяющий сохранять адреса, блоки и диапазоны адресов. Начиная с версии ipset 5, данный тип не поддерживается, при попытке его использования автоматически заменяется на hash:ip. Стоит отметить, что в современных версиях ipset при работе с адресами IPv4 можно указывать диапазоны адресов и подсети, которые при обращении к внутренним спискам будут автоматически преобразованы в наборы соответствующих элементов, Например, <tt>ipset create foo hash:ip; ipset add foo 192.168.0.0-192.168.0.3</tt> добавит в список <tt>foo</tt> адреса 192.168.0.0, 192.168.0.1, 192.168.0.2 и 192.168.0.3 (аналогичный эффект может быть достигнут и командой <tt>ipset add foo 192.168.0.0/30</tt>).

Практически для всех типов списков, реализованных в ipset, существует общее ограничение на максимальный размер: 65536 записей.

Большинство перечисленных типов данных можно разделить на две группы: полные перечни (map, bitmap) и выборочные перечни (hash, tree). Разница между этими типами состоит в следующем: если выборочный перечень сохраняет только те элементы, которые в него входят, то полный перечень представляет собой таблицу логических значений битов для всех элементов, которые могут входить в данный перечень, и вхождение конкретного элемента в перечень определяется значением соответствующего бита. Полный перечень всегда формируется на базе ''одного непрерывного'' диапазона значений.

Таким образом, выбор необходимого вам типа данных определяется конкретными условиями задачи, прежде всего, отношением усредненного количества элементов в списке к требуемому диапазону охвата. Например, если вы собираетесь хранить в списке блэк-листы адресов, замеченных в атаках на ваш сервер, целесообразнее использовать тип hash:ip, потому что атакующие вас ботнеты, как бы они ни были велики, все равно занимают незначительную долю адресного пространства IPv4. К тому же, как следует из сказанного в предыдущем абзаце, тип bitmap:ip все равно не может хранить адреса, выходящие за предел одной подсети префикса 16. Но в том случае, если вам, например, нужно задать список хостов из вашей локальной сети, имеющих доступ к каким-либо услугам (службам вашего сервера, выходу в Интернет), и этот доступ должно иметь значительное количество хостов (а не единицы), то целесообразнее будет использовать bitmap:ip.

По поводу хранения адресов подсетей (блоков IP-адресов) можно сказать следующее. Если вам нужно хранить большое количество блоков одного размера из ограниченного диапазона (не более 65536 возможных значений), например, блоки /24 из подсети /8, вы можете использовать тип bitmap:ip, указав маску. Если же вам нужно хранить блоки одного размера из достаточно широкого диапазона, например, /24 из всего адресного пространства IPv4, используйте тип hash:ip, также с указанием маски. При необходимости хранить в одном списке блоки ''разного'' размера, воспользуйтесь типом hash:net.

Что касается улучшений в версиях 5 и 6 по сравнению с четвертой и более ранними, то, помимо уже упомянутых (поддержка адресов IPv6, поддержка тайм-аутов для всех типов данных, возможность сохранения идентификатора протокола транспортного уровня в типах hash:ip,port, hash:ip,port,ip и hash:ip,port,net), стоит также отметить переход на использование nfnetlink (см. выше) для связи ядра и userspace, а также более простой синтаксис. Например, те действия, которые в ipset 4 выглядели бы так:
<source lang="bash">
ipset -N foo macipmap --network 192.168.0.0/16 # Создаем список
ipset -A foo 192.168.1.1,12:34:56:78:9A:BC # Добавляем запись
ipset -T foo 192.168.1.1,12:34:56:78:9A:BC # Проверяем ее наличие в списке
ipset -L foo # Выводим список на экран (точнее, на stdout)
ipset -F foo # Очищаем список
ipset -X foo # Удаляем список
</source>
в современных версиях ipset будут выглядеть следующим образом:
<source lang="text">
ipset create foo bitmap:ip,mac range 192.168.0.0/16
ipset add foo 192.168.1.1,12:34:56:78:9A:BC
ipset test foo 192.168.1.1,12:34:56:78:9A:BC
ipset list foo
ipset flush foo
ipset destroy foo
</source>
Кроме того, современные версии ipset поддерживают работу в режиме простой оболочки, принимающей команды со stdin. При этом в них обеспечивается полная обратная совместимость синтаксиса с четвертой версией, то есть синтаксис, корректно работающий для четвертой версии ipset, будет точно так же работать в пятой и шестой.

==== ipvs ====

Разработанный в рамках проекта [http://www.linuxvirtualserver.org/ Linux Virtual Server] инструментарий для балансировки входящих соединений на транспортном уровне, позволяющий создавать отказоустойчивые (highly available, HA) кластеры с балансировкой нагрузки. В структуру такого кластера входит один или несколько хостов-балансировщиков (front-end), а также группа хостов-обработчиков (back-end). Хост-балансировщик принимает входящие соединения и перенаправляет их на хосты-обработчики, причем выбор хоста-обработчика осуществляется по специальному алгоритму, обеспечивающему гибкое распределение нагрузки между обработчиками. В кластере также могут присутствовать дополнительные (резервные) балансировщики, которые вступают в игру в случае отказа основного балансировщика.

Как правило, IPVS работает в связке с демоном keepalived, который обеспечивает отказоустойчивость балансировщика (с использованием протокола VRRP) и поддержку в актуальном состоянии списка обработчиков (демон периодически проверяет работоспособность обработчиков и выводит из состава кластера неработоспособные хосты). Также допускается «ручное» управление настройками кластера — через программу ipvsadm]].

Как уже упоминалось выше, IPVS обеспечивает балансировку нагрузки на транспортном уровне, т.е. конфигурационной единицей IPVS является ''кластерная служба''. Она характеризуется адресом (IPv4 или IPv6), протоколом транспортного уровня (на данный момент IPVS поддерживает протоколы TCP,UDP и SCTP) и номером порта. Обычно для кластерных служб выделяется отдельный адрес, который присваивается активному (на данный момент) балансировщику. В случае его отказа, адрес автоматически передается резервному балансировщику, и кластер продолжает работу. Обратите внимание, что обеспечением отказоустойчивости занимается не IPVS, а keepalived. Впрочем, использование keepalived не является строго обязательным — существуют и альтернативные подходы, например, встраивание IPVS в кластерный стек [http://linux-ha.org/ Linux-HA] (см. Heartbeat). В том случае, если отказоустойчивость не критична (требуется только балансировка нагрузки), можно вообще обойтись без дополнительного демона, выполняя всю настройку через ipvsadm.

Для перенаправления пакетов на выбранный обработчик, IPVS может использовать один из следующих методов:
* '''Прямая маршрутизация(gatewaying)''' — применяется в том случае, если между балансировщиком и обработчиками отсутствуют маршрутизаторы, т.е. они находятся в одном сегменте сети. В этом случае адрес назначения в заголовке пакетов сохраняется неизменным («кластерный» адрес), подменяются лишь MAC-адреса назначения при отправке кадров с этими пакетами.
* '''Инкапсуляция IPIP''' — модификация предыдущего метода на тот случай, когда балансировщик и обработчики находятся в разных сегментах сети. При помощи инкапсуляции IP-в-IP создаются сетевые туннели, которые объединяют балансировщик и обработчик в один сегмент виртуальной сети.
* '''Маскарадинг (NAT)''' — наиболее гибкое и универсальное решение: балансировщик подменяет адреса/порты назначения проходящих пакетов на реальные адреса/порты обработчиков трансляция порт-адрес). При этом обеспечивается как простота настройки (не нужно поднимать дополнительные адреса на обработчиках и туннели между балансировщиком и обработчиком), так и гибкость (целевой порт обработчика может отличаться от порта кластерной службы, что невозможно в рамках других методов). Недостатком данного метода является несколько большее потребление системных ресурсов (трансляция адресов является довольно ресурсоемкой задачей).

В настоящее время существует довольно обширная библиотека алгоритмов балансировки нагрузки между обработчиками:
* '''rr (round robin)''' — классическая кольцевая схема, когда все обработчики получают новые соединения поочередно.
* '''wrr (weighted round robin)''' — модификация кольцевой схемы на тот случай, когда одни сервера могут обрабатывать больше соединений, чем другие. Такие сервера включаются в один проход очереди по нескольку раз, и соответственно получают больше соединений.
* '''lc (least-connection)''' — новое соединение передается тому серверу, который на текущий момент обрабатывает наименьшее число соединений.
* '''wlc (weighted least-connection)''' — модификация предыдущего метода на случай, когда возможности серверов отличаются. При выборе нового сервера сравниваются не непосредственно количества открытых соединений, а отношения количества соединений к весовому коэффициенту (весу) обработчика (который и характеризует его возможности).
* '''lblc (locality-based least-connection)''' — формирует привязку обработчиков к кластерному адресу назначения (их может быть несколько). В том случае, если для запрошенного адреса такой привязки еще нет, или привязанный обработчик сильно перегружен — выбирает (по алгоритму lc) и привязывает новый обработчик.
* '''lblcr (locality-based least-connection with replication)''' — несколько усложненный вариант предыдущего алгоритма. К каждому кластерному адресу привязывается группа обработчиков, которая периодически обновляется (исключаются наиболее нагруженные обработчики, вместо них включаются наименее нагруженные).
* '''dh (destination hashing)''' — обеспечивает жесткую, неуправляемую привязку обработчиков к кластерным адресам назначения (выбор обработчика производится исключительно на основании элементарных арифметических операций над кластерным адресом и ''никак не учитывает'' загруженности обработчиков). Может привести к перегрузкам отдельных обработчиков — в этом случае кластер просто перестает обслуживать соответствующий адрес. В такой ситуации нужно либо увеличить лимит соединений на обработчик, либо выбрать другой алгоритм.
* '''sh (source hashing)''' — аналогично dh, но обработчики привязываются к адресам клиентов. Как и dh, в случае перегрузки прекращает обслуживание. Отметим, что для формирования ''временных'' привязок обработчиков к адресам клиентов целесообразнее использовать механизм устойчивых соединений (persistent connections), доступный для всех алгоритмов.
* '''sed (shortest expected delay)''' — выбирает сервер с наименьшей ожидаемой задержкой ответа. Эта задержка определяется как отношение числа обрабатываемых соединений плюс единица к весу обработчика. Таким образом, этот метод по принципу близок к wlc (отличается лишь прибавлением единицы к числителю сравниваемой величины, что немного меняет влияние веса обработчика на выбор).
* '''nq (never queue)''' — пытается передать новое соединение обработчику, который в данный момент не обрабатывает других соединений. Если все обработчики уже заняты, использует предыдущий алгоритм (sed).

Для отслеживания соединений к кластерным службам IPVS использует собственную систему трекинга соединений, более примитивную, но менее ресурсоемкую, нежели классический conntrack. При этом поддерживается экспорт информации о кластерных соединениях в conntrack, в целях обеспечения их корректной обработки фаерволом и трансляции адресов (при трансляции адресов используются штатные средства netfilter). Однако, для корректной обработки протоколов, использующих связанные соединения (например, FTP), IPVS использует возможности conntrack. Синхронизация таблицы соединений между основным и дублирующими балансировщиками полностью реализована на уровне ядра (для сравнения, в conntrack эту задачу выполняет userspace-демон conntrackd).

=== Механизм определения состояний ===

Важной особенностью iptables/netfilter является механизм определения состояний (connection tracking, nf_conntrack) — специальная подсистема, отслеживающая состояния соединений и позволяющая использовать эту информацию при принятии решений о судьбе отдельных пакетов. Наличие этого механизма делает netfilter полноценным stateful-фаерволом.

Определение состояния соединения порою бывает довольно сложной задачей. Скажем, в случае TCP все относительно просто — контроль состояний реализован средствами самого протокола, установлены специальные процедуры открытия и закрытия соединения. А вот в протоколе UDP для этого специальных процедур не предусмотрено, поэтому UDP-соединением с точки зрения conntrack является поток пакетов, следующих с интервалом, не превышающим заданный тайм-аут (sysctl-параметр <tt>net.netfilter.nf_conntrack_udp_timeout</tt>, по умолчанию 30 секунд), с одного и того же порта одного хоста, на один и тот же порт другого хоста.

Заметим, что классификация пакетов по отношению к соединениям, реализуемая системой conntrack, во многих случаях отличается от официального описания сетевых протоколов. Например, с точки зрения критерия conntrack, TCP-пакет SYN/ACK (отвечающий на SYN) — уже часть существующего сеанса, а по определению TCP такой пакет — всего лишь элемент открытия сеанса.

Существует также понятие «связанных соединений». Например, когда в ответ на UDP-пакет с нашего хоста удаленный хост отвечает ICMP-пакетом icmp-port-unreachable, формально этот ответ является отдельным соединением, так как использует совсем другой протокол. netfilter отслеживает подобные ситуации и присваивает таким соединениям статус «связанных» (RELATED), позволяя корректно пропускать их через фильтры фаервола.

Более сложный вариант связанного соединения — соединение данных в пассивном режиме FTP. FTP-сервер самостоятельно выбирает порт для прослушивания из достаточно большого диапазона, и сообщает номер порта клиенту через управляющее соединение, после чего клиент подключается к этому порту и передает данные. netfilter, а точнее модуль conntrack_ftp, выделяет в потоке данных управляющего соединения нужный номер порта, что позволяет корректно определить новое соединение как связанное и, соответственно, корректно пропустить его через правила фильтрации.

В некоторых случаях целесообразно отключить отслеживание состояния соединений. Например, если ваш сервер находится под (D)DoS-атакой типа флуд, и вам удалось локализовать ее источники, отслеживать соединения с атакующих хостов и тратить для этого ресурсы своей системы явно не имеет смысла. В подобных случаях используется действие NOTRACK, применяемое в таблице raw.

Ниже кратко перечислены возможности, предоставляемые системой отслеживания состояний:

==== Критерий состояния соединения ====

При помощи критерия conntrack вы можете классифицировать пакеты на основании их отношения к соединениям. В частности, состояние NEW позволяет выделять только пакеты, открывающие новые соединения, состояние ESTABLISHED — пакеты, принадлежащие к установленным соединениям, состоянию RELATED соответствуют пакеты, открывающие новые соединения, логически связанные с уже установленными (например, соединение данных в пассивном режиме FTP). Состояние INVALID означает, что принадлежность пакета к соединению установить не удалось.

Например, одним простым правилом
<source lang="bash">
iptables -I INPUT -m conntrack --ctstate ESTABLISHED -j ACCEPT
</source>
вы можете обеспечить корректное пропускание всех входящих пакетов, принадлежащих установленным соединениям, и сконцентрироваться только на фильтрации новых соединений.

Заменив в предыдущем правиле <tt>ESTABLISHED</tt> на <tt>ESTABLISHED,RELATED</tt> и подгрузив соответствующие модули ядра, вы автоматически обеспечите корректную фильтрацию протоколов, использующих связанные соединения — FTP, SIP, IRC, H.323 и других. Такое простое (с точки зрения пользователя) решение сложной (с технической точки зрения) проблемы является безусловным достоинством фаервола netfilter и ядра Linux в целом.

Кроме критерия conntrack, стоит упомянуть и его идеологического предшественника — критерий state. Изначально для определения состояния соединения использовался именно он, то есть вместо <tt>-m conntrack --ctstate ESTABLISHED,RELATED</tt> использовалось <tt>-m state --state ESTABLISHED,RELATED</tt>. Подобные формулировки до сих пор сохраняются во многих руководствах по iptables. Однако в настоящее время критерий state считается устаревшим, и разработчики iptables [http://jengelh.medozas.de/documents/Perfect_Ruleset.pdf рекомендуют] использовать вместо него критерий conntrack. Также заметим, что критерий conntrack обладает более широкими возможностями, нежели state, и позволяет использовать дополнительную информацию о соединении, в частности, состояние самого соединения (ctstatus), факт применения к нему трансляции адресов, тайм-аут для «повисших» соединений (ctexpire) и т. п.

==== Маркировка соединений ====

Этот прием позволяет классифицировать соединение в целом на основании информации об отдельном пакете. Выделив этот пакет, вы применяете к нему действие CONNMARK, и выбранную вами маркировку автоматически приобретают все пакеты в соединении. Впоследствии вы можете, например, модифицировать эти пакеты каким-либо образом, или использовать эту маркировку для маршрутизации или шейпинга пакетов. Таким образом, вы оперируете с соединением как с единым целым. Более того, эта маркировка автоматически копируется и на соединения, связанные с текущим.

==== Трансляция сетевых адресов ====

В операциях NAT, производимых с помощью iptables, отслеживание состояний используется автоматически. Вам достаточно указать критерии, под которые подпадет лишь первый пакет в соединении — и трансляция адресов будет применена ко всем пакетам в этом соединении, а также в связанных с ним соединениях.

==== Использование статистики по соединениям ====

Применяя критерий connbytes, вы можете контролировать количество байт или пакетов, переданных по каждому конкретному соединению. В простейшем случае этот механизм может использоваться, скажем, для назначения квот. Более сложный пример — шейпинг пакетов в зависимости от «весовой категории» соединения (ставить пониженный приоритет загрузкам больших файлов).

Этот критерий рассмотрен ниже, в разделе лимитирующие критерии.

==== Ограничение количества соединений ====

Используя критерий connlimit, вы можете ограничивать количество одновременно открытых TCP-соединений с каждого хоста или подсети на ваш сервер, что позволяет обеспечить эффективную защиту от DoS-атак или просто некорректно работающего клиентского ПО.

Этот критерий рассмотрен ниже, в разделе лимитирующие критерии.

==== Отслеживание информации о соединениях ====

Пользователь (точнее, системный администратор) или его процессы могут непосредственно наблюдать таблицу контроля состояний, считывать статистику по передаче данных, а также модифицировать эту таблицу (например, удалять из нее соединения). Для этого существуют специальные утилиты, такие как conntrack или iptstate. Впрочем, можно читать информацию и напрямую из псевдофайлов <tt>/proc/net/nf_conntrack</tt> и <tt>/proc/net/nf_conntrack_expect</tt>.

== Действия ==

=== Переходы ===

Для организации перехода пакета из текущей цепочки в другую (определенную пользователем), просто используйте действие <tt>-j имя_цепочки</tt>. В случае применения в этой цепочке к пакету действия RETURN (см. ниже), пакет вернется в исходную цепочку и продолжит ее прохождение начиная со следующего правила.

Также, существует довольно редко используемое действие «безвозвратного перехода» <tt>-g имя_цепочки</tt>. В таком случае, после прохождения пакетом этой цепочки либо при применении в этой цепочке к пакету действия RETURN, пакет вернется к месту последнего перехода по <tt>-j</tt>. Если таких переходов не было, к пакету сразу будет применено действие по умолчанию для базовой цепочки.

Заметим, что не стоит пытаться перейти в базовую цепочку (например, <tt>-j OUTPUT</tt>), в текущую цепочку (во избежание зацикливания), а также в цепочку, определенную в другой таблице.

=== Встроенные действия ===

Как уже было сказано выше, каждое встроенное действие реализует какую-либо одну операцию, например, ACCEPT пропускает пакет, MARK меняет его маркировку, MASQUERADE обеспечиват маскарадинг соединения. Наиболее общими действиями являются:
* '''ACCEPT''', '''DROP''' и '''REJECT''' — базовые операции фильтрации. Более подробно они рассмотрены ниже, при описании таблицы filter.
* '''RETURN''' — обеспечивает возврат из текущей цепочки. В частности, если из цепочки A правилом номер 3 пакет был направлен в цепочку B, то применение к нему в цепочке B действия RETURN приведет к его переходу обратно в цепочку A, и он продолжит ее прохождение со следующего правила (номер 4).
Например, предположим, что нам нужно обеспечить доступ к определенным портам нашего сервера для всех хостов из подсети 10.134.0.64/26, ''кроме'' 10.134.0.67 и 10.134.0.100.
<source lang="bash">
iptables -F # Очищаем все цепочки таблицы filter
iptables -N our_subnet # Создаем специальную цепочку для проверки пакетов из нашей подсети
iptables -A our_subnet -s 10.134.0.67 -j RETURN # Запрещенный хост — выходим
iptables -A our_subnet -s 10.134.0.100 -j RETURN # Запрещенный хост — выходим
# Всем остальным разрешаем доступ к нужным портам
iptables -A our_subnet -p tcp -m multiport --dports 22,53,8080,139,445 -j ACCEPT
iptables -A our_subnet -p udp -m multiport --dports 53,123,137,138 -j ACCEPT
iptables -A our_subnet -p icmp --icmp-type 8 -j ACCEPT
# Разрешаем пакеты по уже установленным соединениям
iptables -A INPUT -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT
# Все пакеты из нашей подсети отправляем на проверку
iptables -A INPUT -s 10.134.0.64/26 -j our_subnet
iptables -P INPUT DROP # Что не разрешено — то запрещено
iptables -P OUTPUT ACCEPT # На выход — можно все
</source>
Теперь все новые входящие пакеты, отправленные из нашей подсети 10.134.0.64/26, отправляются на проверку в цепочку <tt>our_subnet</tt>. К пакетам с «запрещенных» хостов применяется операция RETURN, и они покидают эту цепочку и впоследствии блокируются действием по умолчанию цепочки INPUT. Пакеты с остальных хостов этой подсети пропускаются в том случае, если они адресованы на порты прокси (8080/tcp), SSH (22/tcp), SMB (139,445/tcp, 137,138/udp), DNS (53/tcp, udp), NTP (123/udp). Также для этих хостов разрешены ICMP-эхо-запросы (пинги). Все остальные пакеты (включая пакеты не из нашей подсети, пакеты с запрещенных хостов и пакеты на неразрешенные порты) блокируются действием по умолчанию DROP.

Нетрудно заметить, что в нашем простом примере вместо RETURN можно было использовать и DROP. Однако, существует понятие «принципа одного запрета». При организации фильтрующих правил в рамках этого принципа, сначала следует серия разрешающих правил, исключения оформляются в виде RETURN, а все не разрешенные пакеты доходят до конца базовой цепочки и блокируются действием по умолчанию либо последним правилом. Следование этому принципу позволяет достичь гибкости в выборе и смене метода блокирования пакетов. Допустим, вы хотите сменить блокирующее действие DROP на REJECT. Нет ничего проще — просто меняете правило по умолчанию. Так же просто вводятся специфические методы блокировки для TCP, например, REJECT <tt>--reject-with tcp-reset</tt> или DELUDE — достаточно просто добавить это действие (вместе с указанием протокола <tt>-p tcp</tt>) в конец цепочки. Все не-TCP пакеты при этом будут по-прежнему блокироваться действием по умолчанию.

Впрочем, изложенный принцип теряет первоначальный смысл, если в разных случаях нужно обеспечить разные способы блокирования. Рассмотрим чуть более сложный пример: допустим, наш сервер подключен к локальной сети 10.0.0.0/8. В ней есть некий «недоверенный» сегмент, скажем, 10.122.0.0/16, для которого нужно полностью заблокировать доступ к нашему серверу. Но в этом сегменте есть несколько «хороших» хостов (скажем, 10.122.72.11 и 10.122.180.91), которые блокировать не нужно. Поставленную задачу можно решить следующим образом:
<source lang="bash">
iptables -F # Очищаем все цепочки таблицы filter
iptables -N check_untrusted # Создаем специальную цепочку для проверки пакетов из нашей подсети
iptables -A check_untrusted -s 10.122.72.11 -j RETURN # Разрешенный хост — выходим
iptables -A check_untrusted -s 10.122.180.91 -j RETURN # Разрешенный хост — выходим
iptables -A check_untrusted -j DROP # Остальных — молча игнорируем
# Разрешаем пакеты по уже установленным соединениям
iptables -A INPUT -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT
# Пакеты из недоверенной подсети проверяем по списку
iptables -A INPUT -s 10.122.0.0/16 -j check_untrusted
# Всем остальным разрешаем доступ к нужным портам
iptables -A INPUT -p tcp -m multiport --dports 22,53,8080,139,445 -j ACCEPT
iptables -A INPUT -p udp -m multiport --dports 53,123,137,138 -j ACCEPT
iptables -A INPUT -p icmp --icmp-type 8 -j ACCEPT
# «Хорошим» хостам, обращающимся на неправильные TCP-порты, вежливо сообщаем об отказе
iptables -A INPUT -p tcp -j REJECT --reject-with tcp-reset
# Для всех остальных протоколов используем стандартный REJECT с icmp-port-unreachable
iptables -P INPUT REJECT
iptables -P OUTPUT ACCEPT # На выход — можно все
</source>
Заметим, что в данном примере хосты из недоверенного сегмента блокируются «молча» (DROP), в то время как при обращении «хороших» хостов на неправильные порты сервер вежливо сообщает им об отказе (REJECT). Этот принцип также является очень важным при построении фаерволов — чем меньше информации попадает к потенциальному злоумышленнику, тем лучше, поэтому на опасных направлениях целесообразно использовать «молчаливое» блокирование, в то время как явные сообщения для «своих» упрощают диагностику работы сети и поиск ошибок.

: ''Примечание: следующий пример планируется к переносу в еще не написанный раздел статьи (Прочие критерии → mac)''.
Например, предположим, что у нас есть объединенная через один свитч подсеть 10.134.0.64/26, к которой наш компьютер подключен через интерфейс eth1. Тогда защиту от спуфинга (подделки адресов отправителя) через проверку MAC-адреса можно обеспечить следующим образом:
<source lang="bash">
sysctl net.ipv4.ip_forward=1 # Разрешаем шлюзу передавать транзитный трафик
iptables -F # Очищаем все цепочки таблицы filter
iptables -N check_ours_sp00f # Создаем цепочку, в которой будут проверяться MAC-адреса
iptables -A check_ours_sp00f -s 10.134.0.67 -m mac --mac-source 00:1D:60:2E:ED:A5 -j RETURN
iptables -A check_ours_sp00f -s 10.134.0.68 -m mac --mac-source 00:1D:60:2E:ED:CD -j RETURN
iptables -A check_ours_sp00f -s 10.134.0.69 -m mac --mac-source 00:1D:60:2E:ED:D7 -j RETURN
iptables -A check_ours_sp00f -s 10.134.0.70 -m mac --mac-source 00:1D:60:2E:ED:E0 -j RETURN
# Аналогичным образом проверяем все адреса нашей подсети
# И в конце обязательно добаляем правило для НЕпрошедших проверку
iptables -A check_ours_sp00f -j DROP
iptables -N check_ours # Создаем цепочку, которая будет описывать логику работы с нашей подсетью
iptables -A check_ours ! -i eth1 -j DROP # С других интерфейсов пакеты от них прийти не могут
iptables -A check_ours -j check_ours_sp00f # Прогоняем их через проверку на спуфинг
iptables -A INPUT -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT # Как обычно, пропускаем все, что идет по установленным соединениям
iptables -A INPUT -s 10.134.0.64/26 -j check_ours # Тех, кто претендует на звание своих, прогоняем через проверку
# Прошедшим проверку разрешаем пользоваться нащей проксёй и самбой, а также соединяться по ssh
iptables -A INPUT -s 10.134.0.64/26 -m multiport --dports 22,8080,139,445 -j ACCEPT
iptables -P INPUT DROP # Остальных блокируем
iptables -A FORWARD -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT # Как обычно, пропускаем все, что идет по установленным соединениям
iptables -A FORWARD -s 10.134.0.64/26 -j check_ours # Проверка
iptables -A FORWARD -s 10.134.0.64/26 -j ACCEPT # Прошедшим проверку разрешаем передавать через нас транзитный трафик
iptables -P FORWARD DROP # Остальных блокируем
iptables -P OUTPUT ACCEPT # Исходящий трафик разрешаем
</source>

Все новые входящие пакеты с обратным адресом из подсети 10.134.0.64/26 проходят двойную проверку в цепочке <tt>check_ours</tt>. Первый этап проверки — соответствие интерфейса. Ведь к нашей подсети, по условию задачи, мы подключены только интерфейсом eth1. Если пакет якобы из этой подсети придет с любого другого интерфейса, он будет заблокирован. Второй этап проверки заключается в последовательном чтении списка соответствующих IP- и MAC-адресов (цепочка <tt>check_ours_sp00f</tt>). Каждое правило этой цепочки, кроме последнего, выделяет пакеты от одного конкретного хоста нашей подсети. К пакетам, прошедшим проверку, применяется операция RETURN, выводящая пакет из этой цепочки. Если же пакет не подошел ни по одному из этих правил, он считается не прошедшим проверки и блокируется последним правилом <tt>-j DROP</tt>. Для прошедших же проверку пакетов дальнейшая судьба зависит от того, кому они адресованы. Если они идут через наш хост в другие подсети, то они пропускаются. Если же они адресованы непосредственно нашему хосту, то пропускаются только соединения на некоторые TCP-порты (прокси, SSH, SMB).
* '''LOG''' — позволяет записывать информацию о пакетах в журнал ядра (см. syslog).
Например, если в предыдущем примере перед строкой
<source lang="bash">
iptables -A INPUT -p tcp -m multiport --dports 22,53,8080,139,445 -j ACCEPT
</source>
мы добавим строку
<source lang="bash">
iptables -A INPUT -p tcp -m multiport --dports 22,53,8080,139,445 -j LOG --log-level INFO --log-prefix "New connection from ours: "
</source>
то для каждого нового соединения к нашему хосту из нашей подсети в системном журнале будет появляться запись примерно такого вида:
Jul 16 20:10:40 interdictor kernel: New connection from ours: IN=eth0 OUT= MAC=00:15:17:4c:89:35:00:1d:60:2e:ed:a5:08:00 SRC=10.134.0.67
DST=10.134.0.65 LEN=48 TOS=0x00 PREC=0x00 TTL=112 ID=38914 DF PROTO=TCP SPT=31521 DPT=8080 WINDOW=65535 RES=0x00 SYN URGP=0
Такая запись содержит очень много полезной информации. Начинается она с даты и времени получения пакета. Затем идет имя нашего хоста (interdictor) и источник сообщения (для сообщений фаервола это всегда ядро). Потом идет заданный нами префикс (<tt>New connection from ours:</tt>), после чего следуют данные о самом пакете: входящий интерфейс (определен для цепочек PREROUTING, INPUT и FORWARD), исходящий интерфейс (определен для цепочек FORWARD, OUTPUT и POSTROUTING), далее — сцепленные вместе MAC-адреса источника и назначения (сначала идет адрес назначения, в данном случае это наш интерфейс eth1 с маком 00:15:17:4C:89:35, затем адрес источника, в нашем случае это 00:1D:60:2E:ED:A5, и в конце следует значение EtherType, 08:00 соответствует протоколу IPv4<ref>Если кратко, EtherType указывает тип протокола, инкапсулированного в Ethernet-кадр. При работе с iptables это значение будет всегда равно 08:00 (протокол IPv4), при работе с ip6tables — 86:DD (IPv6). Полный список EtherTypes доступен [http://www.iana.org/assignments/ethernet-numbers на сайте IANA], список поддерживаемых netfilter’ом — в файле /etc/ethertypes, который в большинстве дистрибутивов находится в пакете ebtables), потом IP-адреса источника (10.134.0.67) и получателя (10.134.0.65, это наш хост), а затем идет различная техническая информация. Например, протокол (TCP), порты источника и назначения (31521 и 8080 соответственно), TOS и TTL, длина пакета (48 байт), наличие флага SYN и т. д.

Указав соответствующие параметры действия LOG, можно дополнить эту информацию номером TCP-последовательности (опция <tt>--log-tcp-sequence</tt>), выводом включенных опций протоколов TCP (опция <tt>--log-tcp-options</tt>) и IP (<tt>--log-ip-options</tt>), а также идентификатором пользователя, процесс которого отправил данный пакет (<tt>--log-uid</tt>, имеет смысл только в цепочках OUTPUT и POSTROUTING).

Параметр <tt>--log-prefix</tt> позволяет задать поясняющую надпись, упрощающую поиск сообщений в системных журналах. Параметр <tt>--log-level</tt> определяет уровень важности лог-сообщения, от которого зависит, в частности, в какой именно из журналов будет записано это сообщение. За более подробными сведениями обратитесь к документации по вашему демону системного лога.
* '''LOGMARK''' — специальная модификация действия LOG, реализованная в комплекте xtables-addons. Отличается тем, что заносит в лог информацию, специфичную для системы conntrack, в частности, маркировку соединения (connmark aka ctmark), состояния соединения (ctstate и ctstatus) и т. п. Например:
Jul 16 20:10:40 interdictor kernel: New connection from ours: iif=1 hook=INPUT nfmark=0x0 secmark=0x0 classify=0x0 ctdir=ORIGINAL
ct=0xf5436bcc ctmark=0x0 ctstate=NEW ctstatus=
<tt>iif</tt> показывает внутренний идентификатор интерфейса, через который прошел пакет (1 в данном случае соответствует eth0, 0 — lo), <tt>hook</tt> — имя цепочки, из которой было вызвано действие LOGMARK, <tt>nfmark</tt> — маркировку пакета (mark), <tt>secmark</tt> — контекст безопасности SELinux данного пакета (secmark), <tt>classify</tt> — класс шейпера (также известный как <tt>skb->priority</tt>, соответствует обычной для tc форме записи ''MAJOR'':''MINOR'' согласно формуле <tt>skb->priority == ''MAJOR'' << 16 | ''MINOR''</tt>), <tt>ctdir</tt> — направление передачи информации с точки зрения conntrack, <tt>ct</tt> — внутренний идентификатор соединения в системе conntrack (точнее говоря, адрес в памяти, по которому расположена структура, хранящая информацию о соединении), <tt>ctmark</tt> — маркировку соединения (connmark), <tt>ctstate</tt> — состояние соединения, <tt>ctstatus</tt> — статус соединения в системе cоnntrack. Более подробно о параметрах ctdir, ctstate и ctstatus вы можете прочитать в описании критерия conntrack. Здесь же ограничимся замечаниями, что «<tt>ctstate=NEW ctstatus=</tt>» соответствует первому пакету в соединении, «<tt>ctstate=ESTABLISHED ctstatus=SEEN_REPLY,CONFIRMED</tt>» — второму и нескольким последующим пакетам, «<tt>ctstate=ESTABLISHED ctstatus=SEEN_REPLY,ASSURED,CONFIRMED</tt>» — пакетам в полностью установленном соединении, «<tt>ct=NULL ctmark=NULL ctstate=INVALID ctstatus=NONE</tt>» — пакету, который не удалось отнести к существующим соединениям, «<tt>ct=UNTRACKED ctmark=NULL ctstate=UNTRACKED ctstatus=NONE</tt>» — пакету, для которого была отключена трассировка conntrack (обычно это выполняется действием NOTRACK в таблице raw.

Таким образом, в сочетании с традиционным LOG, действие LOGMARK позволяет заносить в системный журнал исчерпывающую информацию о пакетах и соединениях.

Заметим, что LOGMARK принимает описанные выше опции <tt>--log-prefix</tt> и <tt>--log-level</tt>.
* '''ULOG''' — позволяет передавать информацию об обработанных пакетах специальным демонам, таким, как [http://www.netfilter.org/projects/ulogd/ ulogd]. Такой подход позволяет эффективно управлять информацией о трафике, в частности, заносить ее в базы данных, такие как MySQL, PostgreSQL или SQLite. Впоследствии эти данные могут быть проанализированы и визуализированы с помощью таких средств, как [http://software.inl.fr/trac/wiki/EdenWall/NuLog NuLog].
* '''NFLOG''' — более универсальный вариант ULOG, обеспечивающий передачу информации о пакете не напрямую в netlink-сокет (как это делает ULOG), а специальной подсистеме — logging backend. Например, бэкенд nfnetlink_log обеспечивает передачу данных в netlink-сокет, то есть с ним NFLOG работает аналогично ULOG.
* '''NFQUEUE''' — во многом похоже на ULOG, но передает специальному демону не информацию о пакете, а сам пакет целиком. Применяется, в частности, для организации работы l7-filter-userspace.
Например, если демон l7-filter был запущен командой
<source lang="bash">
l7-filter -f /etc/l7-filter.conf -q 2
</source>
то передать ему на обработку все входящие и локально сгенерированные пакеты можно командами
<source lang="bash">
iptables -t mangle -F # На всякий случай очищаем таблицу mangle
iptables -t mangle -A PREROUTING -j NFQUEUE --queue-num 2
iptables -t mangle -A OUTPUT -j NFQUEUE --queue-num 2
</source>
Опция <tt>--queue-num</tt> позволяет указать номер очереди пакетов. Он должен быть совпадать с номером, указанным при запуске демона l7-filter (параметр <tt>-q</tt>).
* '''QUEUE''' — устаревшая версия NFQUEUE. Не имеет параметров, так как работает только с очередью номер 0.

Выше были рассмотрены действия «общего назначения», то есть не привязанные по своей специфике к таблицам. Далее, при рассмотрении отдельных таблиц, будут описываться действия, специфичные для каждой таблицы. Термин «специфичные» надо понимать так: совсем не обязательно, что действие, специфичное для одной таблицы, будет в принципе недопустимо в другой, но в любом случае использование этого действия в других таблицах будет «плохим тоном» — ведь таблицы и действия четко разделены по назначению. Не стоит «забивать гвозди микроскопом».

Порой эта разница бывает довольно тонкой. Например, если действие NFQUEUE передает пакеты демону l7-filter-userspace (который занимается маркировкой пакетов на основе анализа их содержимого), то правильнее будет разместить вызов такого действия в таблице mangle. Если же оно передает пакеты демону nufw (который обеспечивает разрешение или запрещение трафика на основе авторизации пользователя), то логичнее разместить это действие в таблице filter.

Кроме того, существуют и ограничения, наложенные непосредственно в коде iptables. Например, действия таблицы nat жестко защищены от употребления за ее пределами. Другой пример: действие REDIRECT можно применять только в цепочках PREROUTING и OUTPUT таблицы nat, то есть ограничения могут быть не только на таблицы, но на отдельные цепочки. Данная статья ни в коем случае не претендует на полноту изложения, поэтому, перед тем как использовать какое-либо действие, обязательно ознакомьтесь с документацией, прилагающейся к вашей версии iptables.

=== Терминальные и нетерминальные действия ===

* ''Терминальными'' называются действия, которые прерывают прохождение пакета через текущую базовую цепочку. То есть если к пакету в рамках некоторого правила было применено терминальное действие, он уже не проверяется на соответствие всем следующим правилам в этой цепочке (и в тех цепочках, из которых она была вызвана, если это пользовательская цепочка). Терминальными являются все действия, специфичные для таблиц filter и nat. Из приведенных выше в этом разделе — ACCEPT, DROP, REJECT, NFQUEUE, QUEUE.
Например,
<source lang="bash">
iptables -A INPUT -p tcp --dport 80 -j ACCEPT
iptables -A INPUT -p tcp --dport 80 -j LOG --log-prefix "IN HTTP: "
</source>
Второе из приведенных правил (логгирование) никогда не будет срабатывать, так как все пакеты, удовлетворяющие этому критерию (входящие TCP-пакеты на порт 80), будут пропущены по первому из этих правил, и до второго просто не дойдут.

* ''Нетерминальными'', соответственно, являются действия, ''не'' прерывающие процесс прохождения пакета через цепочки. Нетерминальными являются действия, специфичные для таблицы mangle, а из перечисленных выше — LOG, ULOG и NFLOG.
Например,
<source lang="bash">
iptables -A INPUT -p tcp --dport 80 -j LOG --log-prefix "IN HTTP: "
iptables -A INPUT -p tcp --dport 80 -j ACCEPT
</source>
Теперь все входящие на TCP-порт 80 пакеты будут сначала заноситься в лог, и только потом пропускаться.

Действие RETURN с точки зрения такой классификации занимает промежуточное положение — оно может прервать прохождение пакета через отдельную цепочку (или несколько цепочек, если для перехода в них использовалась опция <tt>-g</tt>, а не <tt>-j</tt>), но совсем не обязательно, чтобы это приводило к завершению обработки пакета в рамках текущей базовой цепочки.

== Таблицы ==
[[Файл:Netfilter-diagram-rus.png|thumb|400px|Путь проверки пакета в системе netfilter]]

=== Таблица mangle ===
Данная таблица предназначена для операций по классификации и маркировке пакетов и соединений, а также модификации заголовков пакетов (поля TTL и TOS).

==== Цепочки ====
Таблица mangle содержит следующие цепочки:
* '''PREROUTING''' — позволяет модифицировать пакет ''до'' принятия решения о маршрутизации.
* '''INPUT''' — позволяет модифицировать пакет, предназначенный самому хосту.
* '''FORWARD''' — цепочка, позволяющая модифицировать транзитные пакеты.
* '''OUTPUT''' — позволяет модифицировать пакеты, исходящие от самого хоста.
* '''POSTROUTING''' — дает возможность модифицировать все исходящие пакеты, как сгенерированные самим хостом, так и транзитные.

Заметим, что все цепочки таблицы mangle пакеты проходят раньше, чем одноименные цепочки таблиц nat и filter. Это позволяет классифицировать и маркировать пакеты и соединения в цепочках этой таблицы. Впоследствии эти маркировки могут быть использованы в цепочках двух других таблиц при принятии решений о фильтрации и трансляции адресов.

==== Действия ====
Допустимыми действиями в этой таблице являются:
* '''TOS''' — изменяет поле TOS данного пакета. Поддерживаются опции <tt>--set-tos</tt> (установить поле TOS в заданное значение), а также <tt>--and-tos</tt>, <tt>--or-tos</tt> и <tt>--xor-tos</tt>, комбинирующие текущее значение поля TOS с заданным в правиле значением по соответствующему логическому правилу и записывающие результат как новое значения поля TOS.

Кроме того, опция <tt>--set-tos</tt> поддерживает расширенный синтаксис <tt>--set-tos ''значение''/''маска''</tt>. При использовании такого синтаксиса в исходном значении TOS пакета зануляются те биты, которые установлены в маске, затем полученное число XOR’ится с указанным в параметрах значением, и полученная величина записывается в поле TOS. Используя синтаксис языка C, это можно записать так: <tt>NEW_TOS = (OLD_TOS & ~''маска'') ^ ''значение''</tt>. Заметим, что в случае с IPv6 операция отрицания маски не выполняется (то есть в исходном значении зануляются те биты, которые в маске ''не установлены''), хотя это и не отражено в документации.

Также, в случае IPv4 (iptables) в параметре <tt>--set-tos</tt> вы можете указать одно из допустимых символьных обозначений: Minimize-Delay (TOS 16, требование минимальной задержки), Maximize-Throughput (TOS 8, требование максимальной пропускной способности), Maximize-Reliability (TOS 4, максимальная надежность доставки), Minimize-Cost (TOS 2, минимальная стоимость), Normal-Service (TOS 0, специальные требования отсутствуют). В ip6tables использование этих обозначений не запрещено, однако в этом случае более корректным будет использование действия DSCP (см. ниже).

Практический пример использования действия TOS представлен в описании критерия connbytes.

Отметим, что, в соответствии с современными соглашениями, поле TOS в заголовке IP-пакета разделяется на две части:DSCP (первые шесть бит кода TOS) и ECN (последние два бита TOS). Современные версии netfilter/iptables не поддерживают изменение значений ECN в IP-заголовках, поэтому фактически действие TOS работает только с полем DSCP, отличаясь от действия DSCP (см. чуть ниже) разве что интерфейсом (фактически, синтаксисом).

* '''DSCP''' — изменяет поле DSCP (класс DiffServ) в заголовке пакета. Поддерживаются опции <tt>--set-dscp</tt> (позволяет задать значение DSCP числом) и <tt>--set-dscp-class</tt> (позволяет установить заданный класс DiffServ, например, EF или AF13).
* '''TTL''' — изменяет поле TTL данного пакета (работает только с IPv4, для IPv6 используется действие HL). Поддерживаются опции <tt>--ttl-set</tt> (установить поле TTL в заданное значение), а также <tt>--ttl-inc</tt> и <tt>--ttl-dec</tt> (соответственно увеличить или уменьшить текущее значение поля TTL на заданное значение). Допустимые значения TTL — от 0 до 255. При достижении TTL=0 пакет уничтожается.

В качестве полезного примера использования этого действия можно привести команду
<source lang="bash">
iptables -t mangle -I PREROUTING -j TTL --ttl-inc 1
</source>
делающую наш шлюз невидимым для большинства трассировщиков.

Обратите внимание, что автоматически выполняемая сетевым стеком ядра операция уменьшения TTL на единицу и проверки на равенство нулю выполняется ''после'' цепочки PREROUTING, но ''до'' цепочки FORWARD. Таким образом, переместив это правило в цепочку FORWARD, вы обеспечите «невидимость» следующего за вами шлюза.

Другой полезный пример — выравнивание TTL на выходе в Интернет (интерфейс eth0)
<source lang="bash">
iptables -t mangle -I POSTROUTING -o eth0 -j TTL --ttl-set 64
</source>
Некоторые домашние провайдеры, пытаясь бороться с нелегальной перепродажей канала их клиентами, блокируют доступ тем клиентам, на выходе которых замечены пакеты с разными значениями TTL, потому что этот факт косвенно указывает на наличие у клиента внутренней подсети. Предложенное правило, будучи применено на шлюзе такой подсети, делает ее детекцию по TTL крайне затруднительной.

'''Будьте очень осторожны''' с правилами, которые увеличивают или, что особенно опасно, напрямую задают значение TTL, так как, при наличии определенных ошибок маршрутизации, это может привести к появлению «бессмертных» пакетов, которые будут долго циркулировать между одними и теми же узлами, захламляя канал и затрудняя работу сетевого оборудования.

* '''HL''' — изменяет поле Hop Limit в заголовке IPv6-пакета. Является аналогом IPv4-действия TTL и поддерживает те же операции: <tt>--hl-set</tt> (установить поле HL в заданное значение), а также <tt>--hl-inc</tt> и <tt>--hl-dec</tt> (соответственно увеличить или уменьшить текущее значение поля HL на заданное значение).
* '''MARK''' — устанавливает или изменяет маркировку пакета. Поддерживает опции <tt>--set-mark</tt>, <tt>--and-mark</tt>, <tt>--or-mark</tt> и <tt>--xor-mark</tt>, аналогичные опциям действия TOS. Важно понимать, что маркировка пакета не хранится в его заголовке или содержимом, и поэтому действует только в пределах одного хоста. Также нужно отличать маркировку пакета от маркировки соединения. Маркировка пакетов может применяться для их дальнейшей обработки фаерволом (критерии mark и connmark), а также для классификации трафика фильтрами шейпинговой подсистемы tc (лексема handle ''mark'' fw).
* '''CONNMARK''' — устанавливает или изменяет маркировку соединения. Поддерживает те же опции, что и MARK, а также дополнительные опции <tt>--restore-mark</tt> (копирует маркировку соединения в маркировку пакета) и <tt>--save-mark</tt> (копирует маркировку пакета в маркировку соединения).
* '''CLASSIFY''' — устанавливает CBQ-класс пакета для его последующей обработки шейпером (опция <tt>--set-class</tt>).
* '''TCPMSS''' — устанавливает максимальный размер TCP-сегмента. Бывает крайне полезной при использовании VPN-подключения<ref>Обычно проблемы с пониженным MTU в Ethernet-сетях возникают как раз из-за VPN-туннелей</ref> в том случае, если VPN-сервер блокирует ICMP-сообщения destination unreachable/fragmentation needed (тип 3, код 4), тем самым нарушая работу процедуры технологии Path MTU discovery.

С точки зрения клиента, эта проблема выглядит так: пинги проходят нормально, но при попытке открыть какую-либо веб-страницу, браузер «подвисает». При этом с самого шлюза все работает нормально. В этом случае достаточно применить на шлюзе следующую команду
<source lang="bash">
iptables -t mangle -I FORWARD -p tcp --tcp-flags SYN,RST SYN -j TCPMSS --clamp-mss-to-pmtu
</source>
которая обеспечит автоматическую установку размера сегмента в TCP-заголовках SYN- и SYN,ACK-пакетов в соответствии с минимальным из известных нашему шлюзу значений MTU на пути следования пакета. Например, если пакет пришел с интерфейса eth0 (MTU 1500) и уходит через интерфейс ppp0 (MTU 1492), а суммарный размер заголовков сетевого и транспортного уровней составляет 40 байт (20 байт TCP и 20 байт IP), то целесообразно установить MSS равным 1452 байтам.

Помимо возможности автоматического выбора TCP MSS, вы можете задать необходимое значение и вручную, используя параметр <tt>--set-mss ''значение''</tt>. Это бывает полезным в том случае, если вам заведомо известно, что дальше на маршруте встречаются участки с еще меньшим MTU, а пограничные сервера этих участков опять же блокируют ICMP destination unreachable/fragmentation needed.
* '''ECN''' — обеспечивает обнуление ECN-битов (флаги CWR и ECE) в TCP-заголовке (единственная опция <tt>--ecn-tcp-remove</tt>). Может использоваться только в IPv4-модуле (iptables, но не ip6tables) для TCP-пакетов (<tt>-p tcp</tt>). Данное действие предназначено для защиты пакетов от ECN blackholes (маршрутизаторов, которые некорректно обрабатывают пакеты с установленными в TCP-заголовке ECN-битами) — рекомендуется применять это действие ко всем пакетам, уходящим на такие маршрутизаторы. Обратите внимание, что данное действие никак не влияет на ECN-биты в IP-заголовках (последние два бита поля TOS).

Кроме того, данное действие поддерживает три потенциально опасные опции, не отраженные в документации: <tt>--ecn-tcp-cwr</tt> (установка значения бита CWR в TCP-заголовке, 0 или 1), <tt>--ecn-tcp-ece</tt> (установка значения бита ECE в TCP-заголовке, 0 или 1) и <tt>--ecn-ip-ect</tt> (установка значения ECT codepoint в IPv4-заголовке, от 0 до 3). Использование этих опций настолько опасно, что они не отражены даже во встроенной справке iptables (<tt>iptables -j ECN -h</tt>) — их можно увидеть, только изучив [http://git.netfilter.org/cgi-bin/gitweb.cgi?p=iptables.git;a=blob;f=extensions/libipt_ECN.c исходный код]. Без крайней необходимости применять их не рекомендуется.
* '''TCPOPTSTRIP''' — выполняет удаление заданных TCP-опций из заголовка TCP-пакета (единственный параметр <tt>--strip-options ''значение''[,''значение''[,...]]</tt>). Удаляемые опции могут быть указаны через их номера (согласно [http://www.iana.org/assignments/tcp-parameters/tcp-parameters.xhtml списку на сайте IANA]) или в виде символьных обозначений (список обозначений, поддерживаемых в вашей версии iptables можно посмотреть, выполнив команду <tt>iptables -j TCPOPTSTRIP -h</tt>). Разумеется, данное действие допустимо только для протокола TCP (<tt>-p tcp</tt>). Например,
<source lang="bash">
iptables -t mangle -A POSTROUTING -p tcp -j TCPOPTSTRIP --strip-options timestamp
</source>
обеспечит удаление штампов времени (RFC 1323). С одной стороны, такое правило будет препятствовать удаленному злоумышленнику определить аптайм нашего хоста, а также тех хостов, маршрут от которых до злоумышленника проходит через наш хост. С другой стороны, блокирование штампов времени может негативно сказаться на быстродействии сети, особенно если вы используете подключения на скорости 100 МБит и выше. Заметим также, что если вам нужно управлять использованием именно штампов времени для TCP IPv4-пакетов, исходящих от вашего хоста, вы можете воспользоваться sysctl-параметром net.ipv4.tcp_timestamps (1 — штампы включены, 0 — выключены).
* '''TPROXY''' — реализует механизм полностью прозрачного проксирования. Такой подход отличается от традиционно используемого «прозрачного» проксирования (действие REDIRECT таблицы nat) тем, что заголовок пакета никак не модифицируется, в том числе не заменяется IP-адрес назначения (при традиционном прозрачном проксировании он заменяется на адрес проксирующего хоста). Кроме того, полностью прозрачное проксирование является прозрачным с точки зрения обеих общающихся сторон. Например, при проксировании обращений некоторой подсети клиентов к серверам из другой подсети, можно сделать так, чтобы не только клиенты считали, что обращаются напрямую к серверам, но и сервера «видели» настоящие исходные адреса клиентов и могли бы устанавливать с ними обратные соединения (например, в случае активного режима FTP). При традиционном же «прозрачном» проксировании, сервера могут видеть только адрес прокси-сервера.

TPROXY позволяет перенаправить транзитный пакет на локальный сокет типа AF_INET (iptables) или AF_INET6 (ip6tables), заданный портом, а также может промаркировать пакет таким образом, чтобы система марушрутизации (iproute2) не позволила пакету покинуть наш хост. Разумеется, поддержка полностью прозрачного проксирования должна быть реализована и в самом прокси-сервере. В частности, прозрачное проксирование IPv4 HTTP [http://wiki.squid-cache.org/Features/Tproxy4 поддерживается] прокси-сервером Squid начиная с версии 3.1.

В качестве примера можно привести простейший случай конфигурации iptables и iproute2 для обеспечения полностью прозрачного проксирования IPv4 HTTP.
<source lang="bash">
# Добавляем принудительную локальную маршрутизацию для всех адресов в таблицу 120
ip route add local 0.0.0.0/0 dev lo table 120
# Все пакеты, имеющие соответствующую маркировку, направляем в эту таблицу
ip rule add fwmark 120 table 120
# Выполняем проксирование для новых соединений
iptables -t mangle -I PREROUTING -p tcp --dport 80 -j TPROXY --tproxy-mark 120 --on-port 3129
# Перехватываем, маркируем и пропускаем пакеты, принадлежащие проксируемым соединениям
iptables -t mangle -N proxypackets
iptables -t mangle -A proxypackets -j MARK --set-mark 120
iptables -t mangle -A proxypackets -j ACCEPT
# Такие пакеты можно выделять с помощью критерия socket
iptables -t mangle -I PREROUTING -m socket -j proxypackets
</source>
Таким образом, пакеты, перехваченные TPROXY-правилом, маркируются и направляются на локальный сокет (порт 3129), который должен прослушиваться специально сконфигурированным прокси-сервером (в случае Squid, в файл конфигурации <tt>squid.conf</tt> нужно добавить строку <tt>http_port 3129 tproxy</tt>). Все пакеты, принадлежащие уже проксируемым соединениям, перехватываются правилом с критерием socket (этот критерий позволяет определить, существует ли на нашем хосте сокет, связанный с данным пакетом), маркируются и немедленно пропускаются. Отметим, что последнее правило будет обрабатываться раньше, чем правило с TPROXY, так как параметр <tt>-I</tt> обеспечивает вставку правил ''в начало'' цепочки, и при последовательном добавлении нескольких правил с этим параметром, порядок добавленных правил будет обратным порядку их ввода.

=== Таблица nat ===

Предназначена для операций stateful-преобразования сетевых адресов и портов обрабатываемых пакетов.

==== Цепочки ====

Таблица nat содержит следующие цепочки:
* '''PREROUTING''' — в эту цепочку пакеты попадают ''до'' принятия решения о маршрутизации. По сути, термин «решение о маршрутизации» подразумевает деление трафика на входящий (предназначенный самому хосту) и транзитный (идущий через этот хост на другие хосты). Именно на данном этапе нужно проводить операции проброса (DNAT, REDIRECT, NETMAP).
* '''OUTPUT''' — через эту цепочку проходят пакеты, сгенерированные процессами самого хоста. На данном этапе при необходимости можно повторить операции проброса, так локально сгенерированные пакеты ''не'' проходят цепочку PREROUTING и ''не'' обрабатываются ее правилами. См. пример для действия DNAT ниже.
* '''POSTROUTING''' — через эту цепочку проходят все исходящие пакеты, поэтому именно в ней целесообразно проводить операции маскарадинга (SNAT и MASQUERADE).

==== Действия ====

Допустимыми действиями в таблице nat являются:
* '''MASQUERADE''' — подменяет адрес источника для исходящих пакетов адресом того интерфейса, с которого они исходят, то есть осуществляет маскарадинг. Такая операция позволяет, например, предоставлять доступ в Интернет целым локальным сетям через один шлюз.

Допустим, у нас есть локальная сеть 192.168.1.0/255.255.255.0 с несколькими компьютерами, имеющими адреса 192.168.1.2, 192.168.1.3 и т. д. Адрес 192.168.1.1 имеет внутренний (подключенный к локальной сети) сетевой интерфейс шлюза, назовем этот интерфейс eth1. Другой его интерфейс, назовем его eth0, подключен к сети Интернет и имеет адрес, допустим, 208.77.188.166. Тогда, чтобы обеспечить выход хостов из этой локальной сети в Интернет, на шлюзе достаточно выполнить следующие команды
<source lang="bash">
sysctl net.ipv4.ip_forward=1 # Разрешаем шлюзу передавать транзитный трафик
iptables -F FORWARD # На всякий случай очистим цепочку FORWARD
# Разрешаем проходить пакетам по уже установленным соединениям
iptables -A FORWARD -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT
# Разрешаем исходящие соединения из локальной сети к интернет-хостам
iptables -A FORWARD -m conntrack --ctstate NEW -i eth1 -s 192.168.1.0/24 -j ACCEPT
iptables -P FORWARD DROP # Весь остальной транзитный трафик — запрещаем.
iptables -t nat -F POSTROUTING # На всякий случай очистим цепочку POSTROUTING таблицы nat
# Маскарадим весь трафик, идущий через eth0
iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
</source>
Теперь, если один из хостов локальной сети, например, 192.168.1.2, попытается связаться с одним из интернет-хостов, например, 199.204.44.194 (kernel.org), при проходе его пакетов через шлюз, их исходный адрес будет подменяться на внешний адрес шлюза, то есть 208.77.188.166. С точки зрения удаленного хоста (kernel.org), это будет выглядеть, как будто с ним связывается непосредственно сам шлюз. Когда же удаленный хост начнет ответную передачу данных, он будет адресовать их именно шлюзу, то есть 208.77.188.166. Однако, на шлюзе адрес назначения этих пакетов будет подменяться на 192.168.1.2, после чего пакеты будут передаваться настоящему получателю. Для такого обратного преобразования никаких дополнительных правил указывать не нужно — это будет делать все та же операция MASQUERADE. Простота трансляции сетевых адресов является одним из важнейших достоинств stateful-фильтрации.

Если же такой трансляции не производить, удаленный хост просто не сможет ответить на адрес 192.168.1.2, так как адресные пространства локальных сетей изолировано от адресного пространства Интернета. В мире могут существовать миллионы локальных сетей 192.168.1.0/255.255.255.0, и в каждой может быть свой хост 192.168.1.2. Эти сети могут и не быть связаны с Интернетом. Но если они с ним связаны — то только благодаря механизмам трансляции сетевых адресов.

* '''SNAT''' (Source Network Address Translation) — работает аналогично MASQUERADE, однако позволяет указать адрес «внешнего» интерфейса (опция <tt>--to-source</tt>). Такой подход позволяет экономить процессорное время шлюза, так как в случае с MASQUERADE для каждого пакета адрес внешнего интерфейса определяется заново. Таким образом, если в предыдущем примере внешний адрес шлюза 208.77.188.166 является статическим (то есть никогда не меняется), команду
<source lang="bash">
iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
</source>
целесообразно заменить на
<source lang="bash">
iptables -t nat -A POSTROUTING -o eth0 -j SNAT --to-source 208.77.188.166
</source>
Однако, в случае, если внешний адрес шлюза динамический, то есть меняется в начале каждой новой сессии, правильнее будет использовать именно MASQUERADE.

Дополнительно, если на внешнем интерфейсе шлюза «висит» несколько статических адресов, например, 208.77.188.166, 208.77.188.167 и 208.77.188.168, можно использовать балансировку между этими адресами:
<source lang="bash">
iptables -t nat -A POSTROUTING -o eth0 -j SNAT --to-source 208.77.188.166-208.77.188.168
</source>
Теперь для каждого нового соединения адрес для подмены будет выбираться случайным образом.

* '''DNAT''' (Destination Network Address Translation) — подменяет адрес назначения для входящих пакетов, позволяя «пробрасывать» адреса или отдельные порты внутрь локальной сети.

Возвращаясь к предыдущему примеру, предположим, что нам нужно «пробросить» внешний адрес шлюза 208.77.188.166 на хост 192.168.1.2, то есть все, кто будет обращаться по внешнему адресу шлюза 208.77.188.166, должны попадать на хост 192.168.1.2. Это достигается следующими командами:
<source lang="bash">
# Разрешаем шлюзу передавать транзитный трафик
sysctl net.ipv4.ip_forward=1
iptables -t nat -F PREROUTING # На всякий случай очистим цепочку PREROUTING таблицы nat
# Пробрасываем 208.77.188.166 на 192.168.1.2
iptables -t nat -A PREROUTING -d 208.77.188.166 -j DNAT --to-destination 192.168.1.2
iptables -F FORWARD # На всякий случай очистим цепочку FORWARD
# Разрешаем проходить пакетам по уже установленным соединениям
iptables -A FORWARD -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT
# Разрешаем входящие соединения к 192.168.1.2
iptables -A FORWARD -m conntrack --ctstate NEW -d 192.168.1.2 -j ACCEPT
iptables -P FORWARD DROP # Весь остальной транзитный трафик — запрещаем.
</source>
В лучших традициях stateful-фаерволинга, подменяются не только адреса назначения для входящих пакетов (208.77.188.166 -> 192.168.1.2), но и адреса источника для исходящих пакетов (192.168.1.2 -> 208.77.188.166), поэтому для интернет-хостов создается полное впечатление, что они общаются именно с 208.77.188.166.

Однако, при всей своей простоте и наглядности, этот пример имеет два недостатка. Во-первых, из нашей локальной сети 192.168.1.0/24 адрес 208.77.188.166 может быть недоступен, так как 192.168.1.2, увидев, что запрос исходит из его сети, может отправить ответ непосредственно отправителю (например, 192.168.1.3), минуя сам шлюз. Отправитель же будет ждать ответа от 208.77.188.166, и просто проигнорирует ответ от 192.168.1.2. Впрочем, эта проблема легко исправляется добавлением SNAT’а для пробрасываемых пакетов:
<source lang="bash">
iptables -t nat -A POSTROUTING -d 192.168.1.2 -s 192.168.1.0/24 -j SNAT --to-source 192.168.1.1
</source>
Теперь, с точки зрения 192.168.1.2, к нему будет обращаться только сам шлюз (192.168.1.1), поэтому ответ также пойдет через шлюз, где будет корректно оттранслирован. Такое решение тоже имеет недостаток — подмена исходного адреса пакета приводит к тому, что компьютер, на который мы пробрасываем соединение, не может определить реального инициатора соединения. Чтобы уменьшить «вредность» этого правила, в него добавлена опция «-s 192.168.1.0/24», которая ограничивает применение этого правила только пакетами из локальной сети. Таким образом, соединения из локальной сети будут выглядеть как соединения, инициированные шлюзом, а соединения из внешней сети будут иметь свои оригинальные адреса.

Вторым недостатком предложенного примера является некорректная обработка запросов с самого шлюза. Ведь пакеты, генерируемые локальными процессами, не проходят цепочку PREROUTING. Поэтому правило DNAT нужно также добавить и в цепочку OUTPUT таблицы nat:
<source lang="bash">
iptables -t nat -A OUTPUT -d 208.77.188.166 -j DNAT --to-destination 192.168.1.2
</source>
Разумеется, исходящие соединения к 192.168.1.2 и ответы на них должны быть разрешены соответственно в цепочках OUTPUT и INPUT таблицы filter. Самый простой способ сделать это —
<source lang="bash">
iptables -F INPUT # Очищаем цепочку INPUT
# Разрешаем входящие пакеты по уже установленным соединениям
iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -P INPUT DROP # Все остальные входящие пакеты — запрещаем
iptables -F OUTPUT # Очищаем цепочку OUTPUT
iptables -P OUTPUT ACCEPT # Разрешаем исходящие пакеты безо всяких ограничений
</source>

Кроме того, при помощи действия DNAT можно пробрасывать не только сразу весь IP-адрес, но и отдельные TCP- или UDP-порты. Например, если в предыдущем примере мы в каждое из правил
<source lang="bash">
iptables -t nat -A PREROUTING -d 208.77.188.166 -j DNAT --to-destination 192.168.1.2
iptables -t nat -A POSTROUTING -d 192.168.1.2 -s 192.168.1.0/24 -j SNAT --to-source 192.168.1.1
iptables -t nat -A OUTPUT -d 208.77.188.166 -j DNAT --to-destination 192.168.1.2
</source>
добавим
<source lang="bash">
-p tcp --dport 80
</source>
то мы «пробросим» не сам адрес 208.77.188.166, а только его TCP-порт 80 (HTTP). Обращения на все остальные TCP- и UDP-порты, а также ICMP-пакеты, поступившие на адрес 208.77.188.166, будут обрабатываться шлюзом, и лишь входящие TCP-соединения на порт 80 будут передаваться на 192.168.1.2.

Как и SNAT, DNAT поддерживает указание диапазонов адресов для подмены. Таким образом можно, например, балансировать нагрузку между несколькими серверами.

* '''REDIRECT''' — подменяет номер порта в TCP- или UDP-пакете, а также подменяет адрес назначения на свой собственный. Например,
<source lang="bash">
iptables -t nat -A PREROUTING -i eth1 -p tcp --dport 80 -j REDIRECT --to-port 8080
</source>
позволяет «завернуть» все исходящие из локальной сети TCP-соединения на порт 80, на TCP-порт 8080 шлюза. Если этот порт обслуживается специально настроенным прокси-сервером, то можно организовать «прозрачное проксирование» — клиенты из локальной сети даже не будут подозревать, что их запросы идут через прокси-сервер. Разумеется, входящие соединения из локалки на TCP-порт 8080 должны быть разрешены в таблице filter.

Другой полезный пример:
<source lang="bash">
iptables -t nat -A PREROUTING -i eth0 -s 213.180.0.0/16 \
-p tcp --dport 80 -j REDIRECT --to-port 8000
</source>
«заворачивает» все входящие из Интернета, а точнее подсети 213.180.0.0/255.255.0.0 TCP-соединения на порт 80, переадресуя их на порт 8000 того же сервера (где, например, может работать специальный веб-сервер). Как обычно, входящие соединения на TCP-порт 8000 должны быть разрешены в таблице filter.

* '''SAME''' — в зависимости от цепочки (PREROUTING или POSTROUTING) может работать как DNAT или SNAT. Однако, при указании (в параметре <tt>--to-ip</tt>) одного или нескольких диапазонов IP-адресов, определяет для каждого нового соединения подставляемый адрес не случайно, а базируясь на IP-адресе клиента. Таким образом, адрес для подмены остается постоянным для одного и того же клиента при повторных соединениях (что ''не'' выполняется для обычных DNAT/SNAT). В некоторых случаях это бывает важным. Примечание: в соответсвии с iptables-extensions's man page действие SAME убрано и заменено на опцию --persistent для действий '''DNAT'''/'''SNAT'''.
* '''NETMAP''' — позволяет «пробросить» целую сеть. Например, для шлюза, стоящего между сетями 192.168.1.0/24 и 192.168.2.0/24 можно организовать следующий проброс:
<source lang="bash">
iptables -t nat -A PREROUTING -s 192.168.1.0/24 -d 192.168.3.0/24 -j NETMAP --to 192.168.2.2/24
</source>
Теперь, при обращении, например, хоста 192.168.1.3 на IP-адрес 192.168.3.2 он будет попадать на 192.168.2.2 (при условии, что такой транзитный трафик разрешен на шлюзе в цепочке FORWARD таблицы filter, а также на хостах сети 192.168.1.0/24 наш шлюз прописан в качестве шлюза для подсети 192.168.3.0/24).

: ''Примечание: следующее действие планируется к переносу в еще не написанный раздел статьи (Устаревшие критерии и действия)''.
* '''MIRROR''' — довольно интересная игрушка. Меняет местами адрес источника и назначения и высылает пакет обратно. Создано исключительно для демонстрационных целей. Однако, может, например, применяться для защиты от сканирования портов — в результате атакующий сканирует свои собственные порты. Однако наличие двух встречных MIRROR’ов на двух хостах может повлечь бесконечное блуждание одних и тех же пакетов, забивающее канал. Поэтому применяйте это действие с осторожностью.

=== Таблица filter ===

Предназначена для фильтрации трафика, то есть разрешения и запрещения пакетов и соединений.

==== Цепочки ====

Таблица filter содержит следующие цепочки:
* '''INPUT''' — эта цепочка обрабатывает трафик, поступающий непосредственно самому хосту.
* '''FORWARD''' — позволяет фильтровать транзитный трафик.
* '''OUTPUT''' — эта цепочка позволяет фильтровать трафик, исходящий от самого хоста.

==== Действия ====

Допустимыми действиями в таблице filter являются:
* '''ACCEPT''' — пропуск пакета. Пакет покидает текущую базовую цепочку и следует дальше по потоковой диаграмме.
* '''REJECT''' — заблокировать пакет и сообщить его источнику об отказе. По умолчанию об отказе сообщается отправкой ответного ICMP-пакета «icmp-port-unreachable». Однако, это действие поддерживает опцию <tt>--reject-with</tt>, позволяющую указать формулировку сообщения об отказе (возможные значения: <tt>icmp-net-unreachable</tt>, <tt>icmp-host-unreachable</tt>, <tt>icmp-proto-unreachable</tt>, <tt>icmp-net-prohibited</tt>, <tt>icmp-host-prohibited</tt>). Для протокола TCP поддерживается отказ в форме отправки RST-пакета (<tt>--reject-with tcp-reset</tt>).
* '''DROP''' — заблокировать пакет, не сообщая источнику об отказе. Более предпочтительна при фильтрации трафика на интерфейсах, подключенных к интернету, так как понижает информативность сканирования портов хоста злоумышленниками.

Также определенный интерес представляют действия, предоставляемые модулями [http://xtables-addons.sourceforge.net/ xtables-addons] (в настоящее время этот проект уже [http://packages.debian.org/squeeze/xtables-addons-common включен] в Debian testing). Некоторые из них:
* '''STEAL''' — аналогично DROP, но в случае использования в цепочке OUTPUT при блокировании исходящего пакета не сообщает об ошибке приложению, пытавшемуся отправить этот пакет.
* '''TARPIT''' — «подвесить» TCP-соединение. Используется лишь в самых крайних случаях, например, при борьбе с DoS-атаками. Отвечает на входящее соединение, после чего уменьшает размер фрейма до нуля, блокируя возможность передачи данных. Соединение будет «висеть» в таком состоянии пока не истечет тайм-аут на атакующей стороне (обычно 20—30 минут). При этом на такое соединение расходуются системные ресурсы атакующей стороны (процессорное время и оперативная память), что может быть весьма ощутимо при значительном количестве соединений. В случае правильного использования действия TARPIT ресурсы атакуемой стороны практически не расходуются.
Под правильным применением понимается предотвращение обработки таких соединений подсистемой conntrack, так как в противном случае будут расходоваться системные ресурсы самого атакуемого хоста. Например, перед добавлением правила блокирования порта
<source lang="bash">
iptables -I INPUT -p tcp --dport 25 -j TARPIT
</source>
обязательно добавляйте в таблицу raw соответствующее правило
<source lang="bash">
iptables -t raw -I PREROUTING -p tcp --dport 25 -j NOTRACK
</source>
предотвращающее обработку блокируемых соединений подсистемой conntrack.
* '''DELUDE''' — создать видимость открытого TCP-порта. На SYN-пакеты отвечает пакетами SYN/ACK, на все прочие пакеты отвечает RST. Очень полезно для введения в заблуждение злоумышленника, сканирующего порты вашего хоста.
* '''CHAOS''' — для каждого нового TCP-соединения случайно выбрать одно из двух действий. Первое из них — REJECT, второе, в зависимости от выбранной опции, либо TARPIT (<tt>--tarpit</tt>), либо DELUDE (<tt>--delude</tt>). В частности, при использовании действия <tt>CHAOS --delude</tt> для всех неиспользуемых портов, сканирующий ваши порты злоумышленник получит совершенно неверную информацию о состоянии ваших портов. В случае с <tt>CHAOS --tarpit</tt> ситуация усугубится еще и «подвисающими» соединениями.

Особо заметим, что все действия, перечисленные в качестве допустимых в таблице filter, можно применять в любой из цепочек любой из таблиц (конечно, с разумными ограничениями — например, не стоит ставить действия TARPIT, CHAOS и DELUDE для собственных исходящих пакетов). Однако эти действия предназначены именно для фильтрации, и применение их за пределами таблицы filter является дурным тоном. Как и, например, применение действий, специфичных для таблицы mangle, в таблицах filter и nat.

=== Таблица security ===

Предназначена для изменения маркировки безопасности (меток SELinux) пакетов и соединений.

==== Цепочки ====

Аналогичны цепочкам таблицы filter:
* '''INPUT''' — эта цепочка обрабатывает трафик, поступающий непосредственно самому хосту.
* '''FORWARD''' — через эту цепочку проходит транзитный трафик.
* '''OUTPUT''' — эта цепочка позволяет обрабатывать трафик, исходящий от самого хоста.

Так как эта таблица появилась относительно недавно, ее редко можно увидеть на схемах следования пакетов через цепочки и таблицы netfilter'а. Поэтому стоит отметить, что все цепочки таблицы security пакеты проходят непосредственно после одноименных цепочек таблицы filter.

==== Действия ====

Данная таблица добавлена в ядро Linux в версии 2.6.27. Ранее операции с метками безопасности выполнялись в таблице mangle, и в целях обратной совместимости все действия, разрешенные для таблицы security, можно использовать и в таблице mangle.

* '''SECMARK''' — устанавливает для пакета контекст безопасности SELinux (единственная допустимая опция <tt>--selctx</tt>).
* '''CONNSECMARK''' — позволяет скопировать контекст безопасности SELinux с отдельного пакета на соединение в целом (опция <tt>--save</tt>) и наоборот (опция <tt>--restore</tt>).

=== Таблица raw ===

Предназначена для выполнения действий с пакетами до их обработки системой conntrack.

Обратите внимание, что в данной таблице не будут срабатывать критерии, которым для корректной работы необходим conntrack (это критерии conntrack, connmark, connlimit, connbytes).

==== Цепочки ====

* '''PREROUTING''' — в эту цепочку входящие пакеты попадают раньше, чем в любую другую из цепочек iptables, и ''до'' обработки их системой conntrack.
* '''OUTPUT''' — аналогично для пакетов, сгенерированных самим хостом.

==== Действия ====


* '''NOTRACK''' — позволяет предотвратить обработку пакетов системой conntrack. Разумеется, применять его стоит не ко всем пакетам подряд, а только к тем, для которых такая обработка не нужна и даже вредна. Например, к пакетам, к которым впоследствии применяется действие TARPIT (см. выше).
* '''CT''' — более функциональный инструмент, добавленный в версии 2.6.34. Позволяет задать различные настройки conntrack, в соответствии с которыми будет обрабатываться соединение, открытое данным пакетом. В частности, можно:
:* Отключить отслеживание соединения (опция <tt>--notrack</tt>). Таким образом, функциональность действия CT включает и функциональность NOTRACK, так что, возможно, действие NOTRACK будет объявлено устаревшим.
:* Задать вспомогательный модуль (conntrack helper) для данного соединения. Если раньше указать нестандартные порты для такого модуля можно было только в параметрах его загрузки (<tt>/etc/modprobe.conf</tt> или <tt>/etc/modprobe.d/netfilter.conf</tt>, например, <tt>options nf_conntrack_ftp ports=2121</tt>), то теперь это можно сделать и через правила netfilter:
<source lang="bash">
iptables -t raw -I PREROUTING -p tcp --dport 2121 -j CT --helper ftp
</source>
:* Ограничить список событий conntrack, которые будут генерироваться для данного соединения. Например, правило
<source lang="bash">
iptables -t raw -I PREROUTING -p tcp --dport 8000 -j CT --ctevents new,destroy
</source>
: будет предписывать для всех соединений на TCP-порт 8000 генерировать только события «открытие соединения» (NEW) и «завершение соединения» (DESTROY), игнорируя все прочие события. Полный список возможных событий: new, related, destroy, reply, assured, protoinfo, helper, mark, natseqinfo, secmark.
:* Задать ''зону conntrack'' для данного пакета (параметр <tt>--zone</tt>). Механизм зон conntrack позволяет корректно отслеживать, фильтровать и NAT'ить соединения даже в том случае, если хост подключен к нескольким сетям, использующим одинаковые пространства имен, через различные интерфейсы (например, интерфейсы eth0 и eth1 подключены к двум разным сетям, но обе эти сети используют пространство 192.168.0.0/24). Традиционно, для идентификации соединений conntrack использует кортежи (tuples) — набор значений в который входят адреса и порты (в случае ICMP — типы и коды ICMP) источника и назначения при передаче данных в прямом и обратном направлении. Очевидно, что при наличии нескольких подсетей с одинаковыми адресными пространствами, возможно возникновение путаницы, когда сразу нескольким соединениям ставится в соответствие одна и та же запись в таблице соединений. Чтобы избежать такой ситуации, в кортеж был добавлен идентификатор зоны conntrack — целое число, которое можно устанавливать через специальное правило в таблице raw в зависимости от входящего/исходящего интерфейса (как уже говорилось выше, цепочки таблицы raw пакеты проходят еще до обработки их conntrack’ом). Например,
<source lang="bash">
iptables -t raw -I PREROUTING -i eth1 -j CT --zone 1
iptables -t raw -I OUTPUT -o eth1 -j CT --zone 1
</source>
: Таким образом, пакеты, входящие или исходящие через интерфейс eth1, будут получать идентификатор зоны 1, в то время как пакеты интерфейса eth0 будут по-прежнему использовать зону по умолчанию (идентификатор 0), и путаницы не произойдет.
: Кроме того, идентификатор зоны можно задать для каждого интерфейса через sysfs, минуя iptables (псевдофайл <tt>/sys/class/net/имя_интерфейса/nf_ct_zone</tt>):
<source lang="bash">
echo 1 > /sys/class/net/eth1/nf_ct_zone
</source>
: Однако, стоит заметить, что iptables/netfilter позволяют реализовать более гибкую логику управления идентификатором зоны, опирающуюся на различные параметры пакетов, и поэтом данный параметр действия CT может быть полезен при решении различных сложных задач управления трафиком при использовании зон conntrack.
* '''RAWDNAT''' — позволяет выполнять «проброс» адресов и портов «сырым» методом — без использования системы conntrack, то есть без учета состояний соединений. Это действие реализовано в рамках проекта xtables-addons. Применять его можно только в таблице raw. Имеет единственную опцию <tt>--to-destination ''адрес''[/''маска'']</tt>, по смыслу аналогичную опции <tt>--to</tt> действия NETMAP, то есть при указании маски заменяются только те биты в адресе, которые соответствуют единичным битам маски. Биты адреса, соответствующие нулевым битам маски, остаются неизменными. При отсутствии маски изменяется весь адрес.

: Отметим, что в отличие от действий таблицы nat, которые работают только с соединениями в целом, операции «сырого» преобразования адресов работают только с отдельными пакетами, никак не учитывая контекст их передачи. Вышесказанное можно проиллюстрировать, скажем, таким простым примером: для элементарной операции «проброса» внешнего адреса на другой адрес при использовании обычных операций NAT достаточно одного правила<ref>На самом деле, для «чистого» проброса адреса, даже при использовании stateful NAT, необходимо обычно два или три правила, в частности, для проброса соединений с самого сервера в цепочке OUTPUT. Более подробно это описано при рассмотрении операции DNAT таблицы nat, и здесь, с целью упрощения понимания примера, эти аспекты опущены</ref>
<source lang="bash">
iptables -t nat -A PREROUTING -i eth0 -d 212.201.100.135 -j DNAT --to-destination 199.181.132.250
</source>
: в то время как для той же операции при использовании «сырых» преобразований необходимо минимум два правила
<source lang="bash">
iptables -t raw -A PREROUTING -i eth0 -d 212.201.100.135 -j RAWDNAT --to-destination 199.181.132.250
iptables -t rawpost -A POSTROUTING -o eth0 -s 199.181.132.250 -j RAWSNAT --to-source 212.201.100.135
</source>
: Как уже говорилось выше, при использовании обычной операции DNAT в ответных пакетах, приходящих с пробрасываемого адреса (199.181.132.250), производится автоматическая (без необходимости писать для этого отдельные правила) подмена исходного адреса на изначальный (212.201.100.135), и обращающиеся по адресу 212.201.100.135 хосты даже не подозревают, что общаются с кем-то другим. В случае же «сырого» преобразования такая автоматическая обработка невозможна, так как она требует возможности проверять пакеты на принадлежность соединению. С другой стороны, операции «сырого» преобразования являются более гибким инструментом, а также могут работать даже с UNTRACKED и INVALID-пакетами.

=== Таблица rawpost ===

Данная таблица предназначена для выполнения операций «сырого» преобразования адресов (без использования информации о соединениях), которые не могут быть реализованы в рамках таблицы raw, а именно, для операции «сырой» подмены исходного адреса (маскарадинга).

Как и в таблице raw, в rawpost отсутствует возможность обращения к conntrack, поэтому критерии, использующие эту подсистему (conntrack, connmark, connlimit, connbytes), в этой таблице работать не будут.

Данная таблица реализована в рамках проекта xtables-addons и отсутствует в стандартном комплекте iptables/netfilter.

==== Цепочки ====

* '''POSTROUTING''' — обрабатывает весь исходящий трафик.

==== Действия ====

В таблице rawpost можно использовать действие '''RAWSNAT''', выполняющее операцию «сырой» подмены исходного адреса. Имеет единственную опцию <tt>--to-source ''адрес''[/''маска'']</tt>, позволяющую задать новый исходный адрес для обрабатываемых пакетов. Как обычно, при наличии маски, в обрабатываемых адресах изменяются только те биты, которые в маске установлены в единицу, при отсутствии маски адрес изменяется целиком. Например, если по правилу
<source lang="bash">
iptables -t rawpost -A POSTROUTING -o eth0 -s 10.125.0.0/16 -d 172.18.1.100 -j RAWSNAT --to-source 192.168.0.20/16
</source>
будет обработан пакет с исходным адресом 10.125.32.28, то этот адрес будет заменен на 192.168.32.28.

Если же при задании правила маску /16 в параметре <tt>--to-source</tt> опустить, адрес будет заменен на 192.168.0.20. Но так лучше не делать, потому что мы выполняем трансляцию для всех пакетов из подсети 10.125.0.0/16, и без отслеживания соединений не сможем отличить, какие пакеты следует вернуть 10.125.32.28, а какие — другим хостам из этой подсети. Сама же операция «возвращения» пакетов требует отдельного RAWDNAT-правила:
<source lang="bash">
iptables -t raw -A PREROUTING -i eth0 -s 172.18.1.100 -d 192.168.0.0/16 -j RAWDNAT --to-destination 10.125.0.0/16
</source>
которое выполняет обратную подмену, заменяя адреса назначения в пакетах-ответах. Таким образом, хост 172.18.1.100 будет считать, что к нему обращаются хосты из подести 192.168.0.0/16, а вовсе не из 10.125.0.0/16.

Для сравнения, с использованием stateful-преобразования достаточно одного правила
<source lang="bash">
iptables -t nat -A POSTROUTING -o eth0 -s 10.125.0.0/16 -d 172.18.1.100 -j NETMAP --to 192.168.0.0/16
</source>
которое будет обеспечивать все необходимые преобразования адресов.

Заметим, что для корректной работы обеих описанных конфигураций требуется, чтобы хост 172.18.1.100, а также маршрутизаторы на пути от нашего хоста к нему, считали наш хост шлюзом для сети 192.168.0.0/16.

== Критерии ==

Напоминаем, критерий — это логическое выражение, определяющее, соответствует ли пакет или соединение данному конкретному правилу.

В одном правиле можно указать несколько критериев. Для того, чтобы пакет был обработан правилом, должны выполняться ''все'' критерии, то есть критерии неявно объединяются логическим AND.

Также многие критерии и параметры критериев можно инвертировать, поставив перед ними восклицательный знак. В описании синтаксиса таких критериев присутствует пометка «<tt>[!]</tt>». Инверсия меняет смысл критерия или его параметра на ровно противоположный. Например, критерию <tt>-s 127.0.0.1</tt> соответствуют все пакеты, имеющие обратный адрес 127.0.0.1, а критерию <tt>! -s 127.0.0.1</tt> — все пакеты, ''кроме'' имеющих обратный адрес 127.0.0.1. В ранних версиях iptables восклицательный знак можно было ставить между названием критерия и значением, например, <tt>-s ! 127.0.0.1</tt>, однако последние версии iptables (в частности, 1.4.3.2 и выше), уже не поддерживают этот синтаксис, выдавая следующую ошибку:
Using intrapositioned negation (`--option ! this`) is deprecated in favor of extrapositioned (`! --option this`).

Далее мы кратко рассмотрим наиболее важные и интересные критерии.

=== Универсальные критерии ===

Под этим термином понимаются критерии, применимые ко все пакетам и соединениям, независимо от протокола транспортного уровня, и не требующие подключения внешних модулей (<tt>-m</tt>).

* <tt>[!] '''-p'''</tt>, <tt>--protocol ''протокол''</tt>

Позволяет указать протокол транспортного уровня. Наиболее часто употребляются <tt>tcp</tt>, <tt>udp</tt>, <tt>icmp</tt> и <tt>all</tt>. Протокол также можно указать с помощью номера или названия согласно перечню, приведенному в <tt>/etc/protocols</tt>. Значение «любой протокол» можно указать с помощью слова <tt>all</tt> или числа 0. Если протокол не указан, подразумевается «любой протокол».

При указании протокола становится возможным использовать специфичные для него критерии. Например, для TCP и UDP доступны критерии <tt>--sport</tt> и <tt>--dport</tt>, для ICMP — <tt>--icmp-type</tt>. Подробнее эти критерии будут рассмотрены ниже.

* <tt>[!] '''-s'''</tt>, <tt>--src</tt>, <tt>--source ''адрес''[/''маска''][,''адрес''[/''маска'']...]</tt>

Определяет адрес отправителя. В качестве адреса может выступать IP-адрес (возможно с маской), имя хоста из /etc/hosts, или доменное имя (в последних двух случаях перед добавлением правила в цепочку имя резолвится в IP-адрес). Маска подсети может быть указана в классическом формате (например, 255.255.0.0) либо в формате CIDR (например, 16)<ref>Заметим, что для расчета масок подсетей и диапазонов адресов существует очень удобная утилита ipcalc.</ref>. Например,
<source lang="bash">
iptables -I INPUT -i eth0 -s 192.168.0.0/16 -j DROP
</source>
(где eth0 — интерфейс, подключенный к интернету), позволяет заблокировать простейший вид спуфинга — из интернета ''не могут'' приходить пакеты с обратным адресом, принадлежащим к диапазону, зарезервированному для локальных сетей.

Начиная с версии iptables 1.4.6, в одном параметре <tt>-s</tt> можно указывать более одного адреса, разделяя адреса запятой. При этом для каждого адреса будет добавлено ''отдельное'' правило. Например, запись
<source lang="bash">
iptables -A INPUT -i eth0 -s 192.168.0.0/16,172.16.0.0/12,10.0.0.0/8 -j DROP
</source>
эквивалентна записи
<source lang="bash">
iptables -A INPUT -i eth0 -s 192.168.0.0/16 -j DROP
iptables -A INPUT -i eth0 -s 172.16.0.0/12 -j DROP
iptables -A INPUT -i eth0 -s 10.0.0.0/8 -j DROP
</source>
При добавлении через команду <tt>-A</tt> (вставка в конец цепочки) порядок добавляемых правил будет соответствовать порядку перечисления адресов в исходной команде, при использовании команды <tt>-I</tt> (вставка в начало цепочки либо после заданного правила) порядок будет обратным исходному.

Настойчиво не рекомендуется использовать доменные имена, для разрешения (резолва) которых требуются DNS-запросы, так как на этапе конфигурирования фаервола DNS может работать некорректно. Также, заметим, имена резольвятся всего один раз — при добавлении правила в цепочку. Впоследствии соответствующий этому имени IP-адрес может измениться, но на уже записанные правила это никак не повлияет (в них останется старый адрес). Если указать доменное имя, которое резольвится в несколько IP-адресов, то для каждого адреса будет добавлено отдельное правило.

* <tt>[!] '''-d'''</tt>, <tt>--dst</tt>, <tt>--destination ''адрес''[/''маска''][,''адрес''[/''маска'']...]</tt>

Определяет адрес получателя. Синтаксис аналогичен <tt>-s</tt>.

Заметим, что, если использовать возможность указания нескольких адресов (перечислив их явно или указав доменное имя, резольвящееся на несколько адресов) ''одновременно'' в параметрах <tt>-s</tt> и <tt>-d</tt>, то на каждое возможное сочетание адресов будет добавлено свое правило. Например, запись
<source lang="bash">
iptables -A FORWARD -s 192.168.1.1,192.168.1.2 -d 192.168.1.3,192.168.1.4 -j REJECT
</source>
эквивалентна
<source lang="bash">
iptables -A FORWARD -s 192.168.1.1 -d 192.168.1.3 -j REJECT
iptables -A FORWARD -s 192.168.1.1 -d 192.168.1.4 -j REJECT
iptables -A FORWARD -s 192.168.1.2 -d 192.168.1.3 -j REJECT
iptables -A FORWARD -s 192.168.1.2 -d 192.168.1.4 -j REJECT
</source>

* <tt>[!] '''-i'''</tt>, <tt>--in-interface ''имя_интерфейса''</tt>

Определяет входящий сетевой интерфейс. Если указанное имя интерфейса заканчивается знаком «+» (например, <tt>tun+</tt>), то критерию соответствуют все интерфейсы, чьи названия начинаются на указанное имя (для нашего примера tun0, tun1, …). Данный критерий можно использовать в цепочках PREROUTING, INPUT и FORWARD. Например,
<source lang="bash">
iptables -I INPUT -i lo -j ACCEPT
</source>
позволит принимать весь трафик, входящий через интерфейс обратной петли.

* <tt>[!] '''-o'''</tt>, <tt>--out-interface ''имя_интерфейса''</tt>

Определяет исходящий сетевой интерфейс. Синтаксис аналогичен <tt>-i</tt>. Критерий можно использовать в цепочках FORWARD, OUTPUT и POSTROUTING. Вспоминая один из наших примеров,
<source lang="bash">
iptables -t nat -I POSTROUTING -o eth0 -j MASQUERADE
</source>
будет маскарадить весь трафик, исходящий через интерфейс eth0.

=== Критерии, специфичные для протоколов ===

==== Протоколы транспортного уровня ====

===== TCP =====

* <tt>[!] '''--sport'''</tt>, <tt>--source-port ''порт''[:''порт'']</tt>

Позволяет указать исходящий порт (или их диапазон). Например,
<source lang="bash">
iptables -I INPUT -m conntrack --ctstate NEW -p tcp --sport 0:1023 -j DROP
</source>
заблокирует все входящие соединения с привилегированных портов (''привилегированными'' в TCP/UDP считаются порты с 0 по 1023 включительно, так как для их использования нужны привилегии суперпользователя, и обычно такие порты используются демонами только в режиме прослушивания).

* <tt>[!] '''--dport'''</tt>, <tt>--destination-port ''порт''[:''порт'']</tt>

Позволяет указать порт назначения (или их диапазон). Синтаксис аналогичен <tt>--sport</tt>. Например,
<source lang="bash">
iptables -I INPUT -p tcp --dport 80 -j ACCEPT
</source>
разрешит все входящие пакеты на 80 порт (HTTP).

* <tt>[!] '''--tcp-flags''' ''маска'' ''установленные_флаги''</tt>

Позволяет указать список установленных и снятых TCP-флагов. В ''маске'' перечисляются (через запятую, без пробелов) все проверяемые флаги, далее, после пробела, перечисляются (также через запятую) те из них, которые должны быть установлены. Все остальные перечисленные в маске флаги должны быть сняты. Возможные флаги: SYN ACK FIN RST URG PSH. Также можно использовать псевдофлаги ALL и NONE, обозначающие «все флаги» и «ни одного флага» соответственно.

Пример:
<source lang="bash">
iptables -I INPUT -p tcp --tcp-flags SYN,RST,ACK,FIN SYN -j LOG --log-level DEBUG --log-prefix "TCP SYN: "
</source>
будет заносить в лог все входящие TCP SYN-пакеты. У обычного SYN-пакета всегда установлен флаг SYN и сняты флаги RST, ACK и FIN.

Другой пример:
<source lang="bash">
iptables -I INPUT -m conntrack --ctstate NEW,INVALID -p tcp --tcp-flags SYN,ACK SYN,ACK -j REJECT --reject-with tcp-reset
</source>
будет препятствовать спуфингу от нашего имени. Ведь если мы получаем пакет с установленными флагами SYN и ACK (такой комбинацией флагов обладает только ответ на SYN-пакет) по еще не открытому соединению, это означает, что кто-то послал другому хосту SYN-пакет от нашего имени, и ответ пришел к нам. Однако добавление такого правила в конфигурацию фаервола ''не рекомендуется'', поскольку стандартом также предусмотрено использование случайного начального номера последовательности для каждого нового TCP-соединения, как раз для предотвращения возможности спуфинг-атаки. Шансов угадать начальный номер у злоумышленника практически нет, тогда как наш ответ RST-пакетом на такой пакет может серьезно нарушить работоспособность некоторых систем защиты от DoS-атак, полагающихся на метод, называемый out-of-sequence ACK. В случае добавления этого правила в конфигурацию фаервола, системы защиты будут считать, что, раз уж мы отвечаем RST на out-of-sequence ACK, вы действительно пытались установить соединение с ресурсом, и пропустят все последующие поддельные пакеты злоумышленника, отправленные от вашего имени. В результате вы заметно облегчите злоумышленнику осуществление DoS-атаки от вашего имени, и при расследовании этого эпизода следы приведут к вам.

* <tt>[!] '''--syn'''</tt>

Позволяет отлавливать TCP SYN-пакеты (сокращение для <tt>--tcp-flags SYN,RST,ACK,FIN SYN</tt>). Так что приведенный выше пример про логгирование SYN-пакетов можно записать в виде
<source lang="bash">
iptables -I INPUT -p tcp --syn -j LOG --log-level DEBUG --log-prefix "TCP SYN: "
</source>

Более интересный пример:
<source lang="bash">
iptables -I INPUT -m conntrack --ctstate NEW -p tcp ! --syn -j DROP
</source>
будет блокировать все попытки открыть входящее TCP-соединение ''не'' SYN-пакетом. Попытка установить соединение таким образом может быть либо ошибкой, либо атакой.

* <tt>[!] '''--tcp-option''' ''номер''</tt>

Позволяет проверить, установлена ли в заголовке TCP-пакета соответствующая опция. Полный список опций с их номерами представлен [http://www.iana.org/assignments/tcp-parameters/tcp-parameters.xhtml на сайте IANA].

===== UDP =====

* <tt>[!] '''--sport'''</tt>, <tt>--source-port ''порт''[:''порт'']</tt>

Позволяет указать исходящий порт (или их диапазон). Синтаксис и принцип работы аналогичен описанной выше одноименной опции TCP.

* <tt>[!] '''--dport'''</tt>, <tt>--destination-port ''порт''[:''порт'']</tt>

Позволяет указать входящий порт (или их диапазон). Синтаксис и принцип работы аналогичен описанной выше одноименной опции TCP.

===== SCTP =====

* <tt>[!] '''--sport'''</tt>, <tt>--source-port ''порт''[:''порт'']</tt>

Позволяет указать исходящий порт (или их диапазон). Синтаксис и принцип работы аналогичен описанной выше одноименной опции TCP.

* <tt>[!] '''--dport'''</tt>, <tt>--destination-port ''порт''[:''порт'']</tt>

Позволяет указать входящий порт (или их диапазон). Синтаксис и принцип работы аналогичен описанной выше одноименной опции TCP.

* <tt>[!] '''--chunk-types''' {all|any|only} ''тип_секции''[:''флаги''][,''тип_секции''[:''флаги'']...]</tt>

Позволяет анализировать набор секций (chunks), входящих в состав SCTP-пакета. Возможные типы секций: DATA INIT INIT_ACK SACK HEARTBEAT HEARTBEAT_ACK ABORT SHUTDOWN SHUTDOWN_ACK ERROR COOKIE_ECHO COOKIE_ACK ECN_ECNE ECN_CWR SHUTDOWN_COMPLETE ASCONF ASCONF_ACK. Также, для секций, имеющих флаги (DATA, ABORT и SHUTDOWN_COMPLETE) можно проверить состояние флагов, указав соответствующие буквы после названия секции (для DATA — U, B и E, для ABORT и SHUTDOWN_COMPLETE — T). Литера в верхнем регистре предполагает установленный флаг, в нижнем — снятый. Ключевое слово в начале позволяет определить логику работы: в случае <tt>all</tt> должны присутствовать ''все'' перечисленные секции, для <tt>any</tt> — хотя бы одна из них, для <tt>only</tt> — пакет должен состоять только из перечисленных секций. Примеры:
<source lang="bash">
iptables -I INPUT -p sctp --chunk-types only DATA,INIT -j DROP
</source>
заблокирует все входящие SCTP-пакеты, состоящие только из секций DATA и INIT, а
<source lang="bash">
iptables -I INPUT -p sctp --chunk-types any DATA:Be -j ACCEPT
</source>
разрешит входящие SCTP-пакеты, содержащие секцию DATA с установленным флагом B и снятым флагом E, то есть первый фрагмент фрагментированной DATA-секции.

===== DCCP =====

* <tt>[!] '''--sport'''</tt>, <tt>--source-port ''порт''[:''порт'']</tt>

Позволяет указать исходящий порт (или их диапазон). Синтаксис и принцип работы аналогичен описанной выше одноименной опции TCP.

* <tt>[!] '''--dport'''</tt>, <tt>--destination-port ''порт''[:''порт'']</tt>

Позволяет указать входящий порт (или их диапазон). Синтаксис и принцип работы аналогичен описанной выше одноименной опции TCP.

* <tt>[!] '''--dccp-types''' ''маска''</tt>

Позволяет указать тип DCCP-пакета. В ''маске'' через запятую перечисляются DCCP-типы (допустимые названия: REQUEST RESPONSE DATA ACK DATAACK CLOSEREQ CLOSE RESET SYNC SYNCACK INVALID). Пакет считается удовлетворяющим критерию, если имеет один из типов, перечисленных в маске. Например,
<source lang="bash">
iptables -I INPUT -p dccp --dccp-types RESET,INVALID -j LOG --log-level DEBUG --log-prefix "DCCP RESET or INVALID: "
</source>
занесет в лог все входящие RESET и INVALID DCCP-пакеты.

===== UDP Lite =====

Поддержка специфических опций протокола UDPLite (а именно, проверки портов источника и/или назначения) в netfilter реализована не вполне очевидным образом: через критерий multiport).

Если для обычного UDP соответствие номера порта проверялось выражением вида <tt>-p udp --dport ''номер_порта''</tt> (или <tt>-p udp --sport ''номер_порта''</tt>), то в случае UDPLite аналогичное выражение будет выглядеть как <tt>-p udplite -m multiport --dports ''номер_порта''</tt> (или <tt>-p udplite -m multiport --sports ''номер_порта''</tt>). Все опции критерия multiport для UDPLite поддерживаются в полном объеме.

==== IPv4 ====

Ниже перечислены критерии, которые реализованы только для протокола IPv4 и, соответственно, могут быть вызваны только через iptables, но не через ip6tables.

* <tt>[!] '''-f'''</tt>, <tt>--fragment</tt>

Проверка фрагментации: критерию соответствуют только фрагменты пакета, начиная со второго фрагмента. Пример:
<source lang="bash">
iptables -I INPUT -p icmp -f -j DROP
</source>
блокирует фрагменты ICMP-пакетов. Так как, в силу функционального назначения протокола, ICMP-пакеты должны быть очень небольшими и нормально укладываться в MTU, наличие их фрагментов обычно свидетельствует об ошибке или попытке атаки.

У второго и последующего фрагментов нет заголовка транспортного уровня, поэтому бессмысленно пытаться использовать для них критерии номеров TCP/UDP-портов или типа ICMP.

* '''addrtype''' — позволяет проверить тип адреса источника и/или назначения с точки зрения подсистемы маршрутизации сетевого стека ядра. Допустимые типы адресов: UNSPEC (адрес 0.0.0.0), UNICAST, LOCAL (адрес принадлежит нашему хосту), BROADCAST, ANYCAST, MULTICAST, BLACKHOLE, UNREACHABLE, PROHIBIT, THROW, NAT, XRESOLVE. Подробнее о большинстве перечисленных типов адресов и их использовании в Linux (точнее, в подсистеме iproute2) можно почитать [http://linux-ip.net/html/routing-tables.html здесь]. Данный критерий поддерживает следующие параметры:

<tt>[!] --src-type ''тип''[,''тип''...]</tt> — проверка, принадлежит ли исходный адрес пакета одному из перечисленных типов.

<tt>[!] --dst-type ''тип''[,''тип''...]</tt> — проверка, принадлежит ли адрес назначения пакета одному из перечисленных типов.

<tt>--limit-iface-in</tt> — ограничивает проверку типа адреса только записями для интерфейса, через который пакет вошел на хост. Допускается использовать этот параметр только в цепочках PREROUTING, INPUT и FORWARD.

<tt>--limit-iface-out</tt> — ограничивает проверку типа адреса только записями для интерфейса, через который пакет вышел с хоста. Допускается использовать этот параметр только в цепочках POSTROUTING, OUTPUT и FORWARD.

Критерии <tt>--limit-iface-in</tt> и <tt>--limit-iface-out</tt> нельзя указывать одновременно.

В качестве практического примера использования данного критерия можно привести простейшую защиту от спуфинга:
<source lang="bash">
iptables -I INPUT -m addrtype --src-type LOCAL ! -i lo -j DROP
</source>
Это правило заблокирует пакеты, которые пришли с внешних интерфейсов, но при этом в качестве обратного адреса у них указан один из адресов, принадлежащих нашему хосту (например, 127.0.0.1).

* '''ecn''' — позволяет проверять значения битов ECN в заголовках TCP и IPv4. Допустимые параметры:

<tt>[!] --ecn-tcp-cwr</tt> — проверка флага ECN CWR (Congestion Window Received) в TCP-заголовке пакета.

<tt>[!] --ecn-tcp-ece</tt> — проверка флага ECN ECE (ECN Echo) в TCP-заголовке пакета.

<tt>[!] --ecn-ip-ect ''значение''</tt> — проверка значения, сформированного ECN-битами поля TOS (последние два бита). Возможные значения от 0 до 3.

* '''realm''' — проверка области маршрутизации (realm) пакета. Имеет единственный параметр

<tt>[!] --realm ''значение''[/''маска'']</tt>, позволяющий указать численный идентификатор области. Если указана маска, то значение realm каждого проверяемого пакета сначала объединяется с маской при помощи побитового AND, а затем сравнивается со значением, указанным в правиле. Также вместо числа можно указать символьное название области согласно обозначениям в файле <tt>/etc/iproute2/rt_realms</tt> (в этом случае маску использовать нельзя).

* '''ttl''' — обеспечивает проверку поля TTL в заголовке пакета. Позволяет установить, является ли значение TTL проверяемого пакета большим (<tt>--ttl-gt</tt>), меньшим (<tt>--ttl-lt</tt>), равным или не равным (<tt>[!] --ttl-eq</tt>) указанному значению.

===== ICMP =====

ICMP является протоколом контрольных сообщений IPv4. Несмотря на то, что ICMP формально является самостоятельным протоколом, и обращение к соответствующему критерию должно производиться с использованием синтаксиса для протокола (<tt>-p</tt>), а не для вспомогательного критерия (<tt>-m</tt>), де-факто этот протокол неотделим от IPv4, и поэтому соответствующий критерий может использоваться только в iptables, но не в ip6tables.

Критерий этого протокола имеет единственный параметр

<tt>[!] '''--icmp-type''' ''тип''</tt> — обеспечивает проверку типа ICMP-пакета. Список возможных типов выводится по команде <tt>iptables -p icmp -h</tt>. Также можно указать стандартные числовые тип и, при
необходимости, код. Например,
<source lang="bash">
iptables -I INPUT -p icmp --icmp-type echo-request -j ACCEPT
</source>
как и аналогичное
<source lang="bash">
iptables -I INPUT -p icmp --icmp-type 8 -j ACCEPT
</source>
пропустят все входящие ICMP-эхо-запросы (пинги).

==== IPv6 ====

Ниже перечислены критерии, которые реализованы только для протокола IPv6 и, соответственно, могут быть вызваны только через ip6tables, но не через iptables.

Особо отметим, что критерии для некоторых подзаголовков IPv6 (dst, frag, hbh, rt) корректно вызываются ''только'' с использованием синтаксиса для расширенных критериев (ключ <tt>-m</tt>), хотя имеют номера протоколов в <tt>/etc/protocols</tt> и, формально, могут быть вызваны с использованием синтаксиса для протоколов (ключ <tt>-p</tt>) что, однако, является неверным. В таких случаях ip6tables выдает предупреждение вида
<source lang="text">
Warning: never matched protocol: ipv6-frag. use extension match instead.
</source>
гласящее, что в такое правило никогда не будет срабатывать. Если вы видите подобное предупреждение, удалите правило, которое его вызвало, и перепишите это правило с использованием корректного синтаксиса (<tt>-m</tt>).

С другими же критериями, которые представляют более или менее самостоятельные протоколы (ICMPv6, MH, IPSec, AH и ESP), все ровно наоборот, и для них корректным будет использование именно синтаксиса протокола (ключ <tt>-p</tt>), а не расширенного критерия. Во избежание путаницы, такие критерии вынесены в отдельные подзаголовки, по аналогии с протоколами транспортного уровня (выше).

* '''dst''' — проверят опции назначения (подзаголовок 60 Destination Options). Имеет две опции:

<tt>[!] --dst-len ''значение''</tt> — проверяет длину подзаголовка;

<tt>[!] --dst-opts ''код''[:''длина''][,''код''[:''длина'']...]</tt> — позволяет проверить вхождение в данный подзаголовок конкретных опций. Также можно проверить длину каждой из них. Можно указать до 16 опций (представленных числовыми кодами), разделяя их запятой.

* '''eui64''' — сравнивает младшие 64 бита исходного IPv6-адреса с битами исходного MAC-адреса, преобразованными согласно правилам автоконфигурирования IPv6-адресов на основании MAC-адресов. Таким образом, позволяет проверить, является ли IPv6-адрес отправителя пакета автоматически сконфигурированным (работает, если отправитель находится в одном широковещательном домене с нашим хостом, так как в противном случае сохранность MAC-адреса отправителя не может быть гарантирована).
* '''frag''' — позволяет проверять параметры фрагментации (подзаголовок 44 Fragment). Допустимые опции:

<tt>[!] --fragid ''мин''[:''макс'']</tt> — сверяет величину идентификатора фрагмента. Если указано одно значение, проверяется равенство, если указан диапазон — проверяется вхождение значения в этот диапазон (включая границы).

<tt>--fragres</tt> — проверяет, заполнены ли нулями зарезервированные поля заголовка (биты 29-30).

<tt>--fragfirst</tt> — проверяет, является ли данный фрагмент первым в последовательности.

<tt>--fraglast</tt>/<tt>--fragmore</tt> — проверяют M-флаг, показывающий, является ли данный фрагмент последним в последовательности (в этом случае <tt>--fraglast</tt> дает истину, а <tt>--fragmore</tt> ложь), или после него должны быть еще фрагменты (соответственно, наоборот). Эти две опции являются взаимоисключающими.

Также в документации можно найти упоминание параметра <tt>--fraglen </tt>, который якобы проверяет длину подзаголовка Fragment. Однако, согласно текущим соглашениям, длина этого подзаголовка фиксирована и равна 8  байтам, а названная опция ни на что не влияет.

* '''hbh''' — проверяет опции Hop-by-Hop (подзаголовок 0 Hop-by-Hop). Синтаксис аналогичен параметру dst.
* '''hl''' — обеспечивает проверку поля Hop Limit в IPv6-заголовке. Позволяет установить, является ли значение HL проверяемого пакета большим (<tt>--hl-gt</tt>), меньшим (<tt>--hl-lt</tt>), равным или не равным (<tt>[!] --hl-eq</tt>) указанному значению.
* '''ipv6header''' — позволяет проверить наличие вспомогательных подзаголовков IPv6. Допустимыми типами заголовков являются: hop (hop-by-hop 0), dst (ipv6-opts 60), route (ipv6-route 43), frag (ipv6-frag 44), auth (ah 50), esp (esp 59). В скобках указаны «длинные» названия и числовые идентификаторы протокола. Используя опцию

<tt>[!] --header ''тип''[,''тип''...]</tt>

вы можете указывать любые из этих обозначений — короткие названия, длинные названия или числовые идентификаторы. Отметим, что пакет будет соответствовать критерию в том случае, если будет содержать ''только'' перечисленные подзаголовки. Изменить это поведение можно, указав опцию <tt>--soft</tt> — в этом случае достаточно, чтобы пакет содержал хотя бы один из перечисленных подзаголовков.

* '''rt''' — позволяет проверять параметры маршрутизации пакета (подзаголовок 43 Routing). Допустимые параметры:

<tt>[!] --rt-type ''тип''</tt> — тип маршрутизации (0, 1 или 2);

<tt>[!] --rt-segsleft ''мин''[:''макс'']</tt> — проверка значения поля Segment Left (показывает, сколько еще узлов должен пройти данный пакет, прежде чем достигнет цели);

<tt>[!] --rt-len ''значение''</tt> — проверка длины всего подзаголовка.

Следующие три параметра работают для типа 0 (<tt>--rt-type 0</tt>):

<tt>--rt-0-res</tt> — проверять зарезервированные поля;

<tt>--rt-0-addrs ''адрес''[,''адрес''...]</tt> — проверяет адреса, перечисленные в подзаголовке. Можно указать не более 16 адресов, разделяя их запятыми. Пакет считается удовлетворяющим критерию, если подзаголовок содержит все адреса, которые были перечислены в правиле, в том же порядке;

<tt>--rt-0-not-strict</tt> — делает условие проверки по предыдущем параметру не таким жестким: достаточно, чтобы хотя бы один из перечисленных адресов совпадал с соответствующим адресом в подзаголовке, при соблюдении порядка перечисления.

===== ICMPv6 =====

ICMPv6 является протоколом контрольных сообщений IPv6. Несмотря на то, что ICMPv6 формально является самостоятельным протоколом, и обращение к соответствующему критерию должно производиться с использованием синтаксиса для протокола (<tt>-p</tt>), а не для вспомогательного критерия (<tt>-m</tt>), де-факто этот протокол неотделим от IPv6, и поэтому соответствующий критерий может использоваться только в ip6tables, но не в iptables.

Критерий этого протокола имеет единственный параметр

<tt>[!] '''--icmpv6-type''' ''тип''</tt>

по смыслу и синтаксису аналогичный параметру <tt>--icmp-type</tt> критерия icmp. Например,
<source lang="bash">
ip6tables -I INPUT -p icmpv6 --icmpv6-type echo-request -j ACCEPT
</source>
как и аналогичное
<source lang="bash">
ip6tables -I INPUT -p icmpv6 --icmpv6-type 128 -j ACCEPT
</source>
пропустит входящие ICMPv6-эхо-запросы (пинги).

Как и в случае icmp, вы можете получить список допустимых типов сообщений, введя
<source lang="bash">
ip6tables -p icmpv6 -h
</source>

===== MH =====

Критерий mh позволяет определять пакеты с подзаголовком IPv6 Mobility Header (RFC 3775). Как и в случае с ICMPv6, вызов данного критерия должен выполняться в соответствии с синтаксисом для протокола (через ключ <tt>-p</tt>). Имеет единственную опцию

<tt>[!] '''--mh-type''' ''мин''[:''макс'']</tt>

позволяющую указать точное значение типа или диапазон допустимых значений. Перечень поддерживаемых типов MH можно получить, введя команду
<source lang="bash">
ip6tables -p mh -h
</source>

Также к данному критерию допустимо обращение по названию ipv6-mh (<tt>-p ipv6-mh</tt>).

==== IPsec ====

netfilter «знает» два протокола из семейства IPsec: Authentication Header (<tt>-p ah</tt>) и Encapsulating Security Payload (<tt>-p esp</tt>).

===== AH =====
Для протокола AH поддерживается единственная опция
* <tt>'''--ahspi''' ''значение''[:''значение'']</tt> — позволяет указать значение (или диапазон значений) SPI (Security Parameter Index).

===== ESP =====
Протокол ESP имеет аналогичную по смыслу опцию
* <tt>'''--espspi''' ''значение''[:''значение'']</tt>

В большинстве конфигураций IPsec-пакеты просто пропускаются фаерволом (пусть с ними разбирается IPsec-подсистема):
<source lang="bash">
iptables -I INPUT -p ah -j ACCEPT
iptables -I INPUT -p esp -j ACCEPT
</source>

=== Критерии состояния соединения ===

==== conntrack ====

Основной критерий, используемый для контроля состояния соединения. Он предоставляет эффективный набор инструментов, позволяющий использовать информацию системы conntrack о состоянии соединения. Затронутую тему весьма проблематично осветить в двух словах и привести по ней простые примеры, не выходя за краткий формат, принятый для нашей статьи. Поэтому ограничимся мы подробно рассмотрим лишь наиболее важный параметр данного критерия — ctstate. Для прочих параметров мы лишь кратко опишем синтаксис и назначение. За более подробной информацией обратитесь к документации, прилагаемой к вашему дистрибутиву. Итак,

* <tt>[!] '''--ctstate''' ''маска''</tt>

''Маска'' содержит перечисление через запятую список возможных состояний соединения. Пакет считается удовлетворяющим критерию, если соединение, по которому он проходит, находится в одном из перечисленных состояний.

Возможные состояния:

:* '''NEW''' — соединение не открыто, то есть пакет является первым в соединении. Полезные примеры использования этого состояния приведены выше, в частности, при описании TCP-специфичных критериев.

:* '''ESTABLISHED''' — пакет относится к уже установленному соединению. Обычно такие пакеты принимаются без дополнительной фильтрации, как и в случае с RELATED.

:* '''RELATED''' — пакет открывает новое соединение, логически связанное с уже установленными, например, открытие канала данных в пассивном режиме FTP.
Например:
<source lang="bash">
modprobe nf_conntrack_ftp # Подгружаем модуль для распознавания связанных FTP-соединений
# В старых системах этот модуль может называться ip_conntrack_ftp
iptables -F # Очищаем все цепочки таблицы filter
# Ко всем пакетам, которые относятся к уже установленным соединениям, применяем терминальное действие ACCEPT — пропустить
iptables -A INPUT -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT
iptables -A INPUT -m conntrack --ctstate NEW -p tcp --dport 21 -j ACCEPT # Разрешаем открывать соединения на 21 TCP-порт.
iptables -P INPUT DROP # В качестве действия по умолчанию устанавливаем DROP — блокирование пакета
iptables -P OUTPUT ACCEPT # Разрешаем все исходящие пакеты
</source>
Этот набор команд обеспечит функционирование на хосте FTP-сервера с поддержкой как активного, так и пассивного режимов. В пассивном режиме FTP клиент сначала устанавливает управляющее соединение на TCP-порт 21 сервера. Когда возникнет необходимость передачи данных, клиент даст серверу команду PASV. Сервер выберет высокий порт и подключится к нему в режиме прослушивания, отправив номер порта клиенту по управляющему соединению. Система conntrack, при наличии подгруженного модуля ядра nf_conntrack_ftp, зафиксирует это сообщение и выделит номер порта. Когда клиент откроет соединение данных на этот высокий порт, система conntrack присвоит первому пакету статус RELATED, в результате чего пакет пройдет по нашему правилу и будет принят. Остальные пакеты в этом соединении будут иметь уже статус ESTABLISHED и тоже будут приняты.

Возможность корректно обрабатывать пассивный режим FTP, как это было описано выше, из всех unix-фаерволов доступна только в iptables. В других фаерволах для решения данной проблемы используются различные «костыли». Например, в pf управляющие FTP-соединения [http://www.openbsd.org/faq/pf/ftp.html#client пропускаются] через специальную программу [http://www.openbsd.org/cgi-bin/man.cgi?query=ftp-proxy&sektion=8 ftp-proxy], которая анализирует трафик подобно conntrack и «на лету» добавляет правила для соединений данных. Однако даже подобные «костыли» существуют далеко не для всех протоколов. Поэтому можно утверждать, что в данном аспекте iptables находится вне конкуренции.

С обработкой активного режима таких проблем не возникает, так как сервер сам устанавливает соединение данных с порта 20, поэтому первый пакет пропускается согласно правилу по умолчанию цепочки OUTPUT. Правда, проблемы могут возникнуть на стороне фаервола клиента, но это уже не относится к компетенции сервера.

:* '''INVALID''' — пакет по смыслу должен принадлежать уже установленному соединению (например, ICMP-сообщение port-unreachable), однако такое соединение в системе не зарегистрировано. Обычно к таким пакетам применяют действие DROP:
<source lang="bash">
iptables -I INPUT -m conntrack --ctstate INVALID -j DROP
</source>

:* '''UNTRACKED''' — отслеживание состояния соединения для данного пакета было отключено. Обычно оно отключается с помощью действия NOTRACK в таблице raw.

:* '''DNAT''' — показывает, что к данному соединению применена операция подмены адреса назначения.

:* '''SNAT''' — показывает, что к данному соединению применена операция подмены адреса источника.

Остальные параметры критерия conntrack, как уже говорилось, мы опишем лишь конспективно.

* <tt>[!] '''--ctstatus''' ''маска''</tt>

Применяется для определения статуса соединения в системе conntrack. Возможные статусы:
:* '''EXPECTED''' — данное соединение ожидалось системой conntrack по результатам анализа других соединений. Например, после того, как клиент и сервер через управляющее FTP-соединение согласуют номер порта для соединения данных в пассивном режиме, система conntrack на сервере будет ожидать входящее соединение на этот порт.
:* '''CONFIRMED''' — подтвержденное соединение. Такой статус присваивается соединению после того, как инициатор начал передачу пакетов.
:* '''SEEN_REPLY''' — соединение, по которому поступил ответ, то есть имеет место передача данных в обоих направлениях (поддержка данного состояния появилась сравнительно недавно).
:* '''ASSURED''' — соединение можно считать полностью установленным. Этот статус присваивается соединению после передачи определенного количества данных. Присвоение данного статуса приводит к увеличению conntrack-тайм-аута для данного соединения (эти тайм-ауты используются для определения и удаления «повисших» и оборванных соединений).
:* '''NONE''' — нет статуса. Соединение не соответствует ни одному из перечисленных критериев.

* <tt>[!] '''--ctproto''' ''протокол''</tt>

Протокол транспортного уровня, определенный системой conntrack. Синтаксис аналогичен стандартному критерию <tt>-p</tt>.

* <tt>[!] '''--ctdir''' {ORIGINAL|REPLY}</tt>

Позволяет указать направление прохождения пакетов (ORIGINAL — от инициатора к отвечающему, REPLY — наоборот). Если не указывать эту опцию, под критерий будут подпадать пакеты, идущие в обоих направлениях.

* <tt>[!] '''--ctorigsrc''' ''адрес''[/''маска'']</tt>, <tt>[!] '''--ctorigdst''' ''адрес''[/''маска'']</tt>, <tt>[!] '''--ctreplsrc''' ''адрес''[/''маска'']</tt>, <tt>[!] '''--ctrepldst''' ''адрес''[/''маска'']</tt>

Позволяет определять адреса источника (src) и назначения (dst) при передаче данных от инициатора к отвечающему (orig) и наоборот (repl). Синтаксис аналогичен описанному выше стандартному критерию <tt>-s</tt>.

Обычно адрес-порт источника при передаче в прямом направлении совпадают с адресом-портом назначения при передаче в обратном направлении, и наоборот, адрес-порт источника при передаче в обратном направлении совпадает с адресом-портом назначения при передаче в прямом направлении. То есть, если клиент 192.168.1.2 обращается к серверу 192.168.1.1, то с точки зрения системы conntrack ситуация выглядит следующим образом:
: → В прямом направлении (от инициатора к отвечающему):
:: — Адрес источника (ctorigsrc): 192.168.1.2 (адрес клиента)
:: — Адрес назначения (ctorigdst): 192.168.1.1 (адрес сервера)
: ← В обратном направлении (от отвечающего к инициатору):
:: — Адрес источника (ctreplsrc): 192.168.1.1 (адрес сервера)
:: — Адрес назначения (ctrepldst): 192.168.1.2 (адрес клиента)

Однако для соединений, к которым применена трансляция адресов или портов, это может не выполняться. Например, рассмотрим ситуацию, когда клиент из нашей подсети (192.168.1.2) обращается к некоторому серверу в интернете (204.152.191.37) через наш сервер (внешний адрес нашего сервера 208.77.188.166, внутренний 192.168.1.1). Для корректной работы такой схемы нужно обеспечить на нашем сервере подмену исходного адреса (SNAT), например,
<source lang="bash">
iptables -t nat -A POSTROUTING -o eth0 -j SNAT --to-source 208.77.188.166
</source>
Тогда, с точки зрения системы conntrack нашего сервера,
: → В прямом направлении (от инициатора к отвечающему):
:: — Адрес источника (ctorigsrc): 192.168.1.2 (внутренний адрес клиента)
:: — Адрес назначения (ctorigdst): 204.152.191.37 (адрес интернет-сервера)
: ← В обратном направлении (от отвечающего к инициатору):
:: — Адрес источника (ctreplsrc): 204.152.191.37 (адрес интернет-севера)
:: — Адрес назначения (ctrepldst): 208.77.188.166 (внешний адрес нашего сервера)

В том случае, если адрес-порт источника при передаче в прямом направлении отличаются от адреса-порта назначения при передаче в обратном направлении, соединению будет присвоен статус SNAT.

Аналогично, если один из внешних адресов нашего сервера «проброшен» на внутренний сервер, например, так
<source lang="bash">
iptables -t nat -A PREROUTING -d 208.77.188.166 -j DNAT --to-destination 192.168.1.2
</source>
то при обращении на этот адрес клиента извне (допустим, все тот же 204.152.191.37), получим
: → В прямом направлении (от инициатора к отвечающему):
:: — Адрес источника (ctorigsrc): 204.152.191.37 (адрес клиента)
:: — Адрес назначения (ctorigdst): 208.77.188.166 (наш внешний адрес)
: ← В обратном направлении (от отвечающего к инициатору):
:: — Адрес источника (ctreplsrc): 192.168.1.2 (адрес внутреннего сервера)
:: — Адрес назначения (ctrepldst): 204.152.191.37 (адрес клиента)

В том случае, если адрес-порт назначения при передаче в прямом направлении отличаются от адреса-порта источника при передаче в обратном направлении, соединению будет присвоен статус DNAT.

* <tt>[!] '''--ctorigsrcport''' ''порт''</tt>, <tt>[!] '''--ctorigdstport''' ''порт''</tt>, <tt>[!] '''--ctreplsrcport''' ''порт''</tt>, <tt>[!] '''--ctrepldstport''' ''порт''</tt>

Позволяет определять порты источника (src) и назначения (dst) при передаче данных от инициатора к отвечающему (orig) и наоборот (repl) для протоколов транспортного уровня, имеющих порты (TCP, UDP, SCTP, DCCP).

Ситуация с портами в принципе аналогична описанной выше ситуации с адресами, поэтому рассматривать ее отдельно мы не будем.

* <tt>[!] '''--ctexpire''' ''мин_время''[:''макс_время'']</tt>

Позволяет указать в качестве критерия оставшееся по тайм-ауту время в секундах для данного соединения.

Система conntrack присваивает каждому соединению тайм-аут (счетчик обратного отсчета времени). Когда этот счетчик доходит до нуля, система conntrack удаляет информацию о соединении из своих таблиц. Тайм-аут устанавливается в значение по умолчанию каждый раз, когда по соединению передаются данные. Таким образом, активно используемые соединения никогда не будут сброшены.

Заметим, что значения тайм-аута по умолчанию для разных протоколов, и даже для одного протокола на разных стадиях установки соединения, могут различаться. Например, для протокола TCP вводятся отдельные значения тайм-аутов для состояний SYN_SENT, SYN_RECV, ESTABLISHED (не путать TCP-состояние ESTABLISHED с conntrack-состоянием ESTABLISHED), FIN_WAIT, CLOSE_WAIT, LAST_ACK, TIME_WAIT, CLOSE. Для UDP существуют два тайм-аута: для соединений, не получивших статуса ASSURED (conntrack_udp_timeout) и для соединений, по которым передано достаточное количество данных в обе стороны для получения этого статуса (conntrack_udp_timeout_stream). Для ICMP тайм-аут только один.

==== state ====

Идеологический предшественник критерия conntrack. Имеет единственный параметр <tt>--state</tt>, аналогичный параметру <tt>--ctstate</tt> критерия conntrack (но, в отличие от него, не поддерживающий состояния DNAT и SNAT).

Долгое время был основным критерием определения состояния, и до сих пор фигурирует во многих руководствах и примерах. Однако в настоящее время разработчики iptables рекомендуют использовать вместо него критерий conntrack. Возможно, что критерий state вообще будет удален из будущих версий iptables/netfilter.

=== Дополнительные критерии ===

Дополнительные критерии iptables подгружаются при помощи параметра <tt>-m</tt> (<tt>--match</tt>). Далее можно указать дополнительные параметры, специфичные для данного конкретного критерия. Если дополнительных критериев несколько, не смешивайте их параметры — указывайте нужные параметры каждого критерия непосредственно после его вызова через <tt>-m</tt>.

Перед некоторыми дополнительными параметрами критерия может стоять восклицательный знак. В соответствии с принятыми в iptables соглашениями, это означает логическую инверсию параметра, то есть его смысл меняется на противоположный. Но такая возможность предусмотрена отнюдь не для всех параметров.

Заметим, что перечисленные выше критерии состояния и критерии, специфичные для протоколов, по сути также являются параметрами соответствующих дополнительных критериев (например, при указании <tt>-p tcp</tt> подразумевается еще и <tt>-m tcp</tt>). Однако в силу ряда причин более логичным и понятным было их отделение от остальных дополнительных критериев. Обратите внимание, что ''все'' параметры вышеперечисленных критериев допускают логическое отрицание (например, <tt>-m conntrack ! --ctstate NEW</tt>).

Справочную информацию по любому из дополнительных критериев можно получить, используя команду
<source lang="bash">
iptables -m название_критерия -h
</source>

==== Вспомогательные критерии ====

К этой группе можно отнести критерии, расширяющие возможности других критериев.

* '''multiport''' — позволяет указать несколько (до 15) портов и/или их диапазонов (для протоколов TCP, UDP, SCTP, DCCP и UDP Lite). Поддерживает следующие параметры

<tt>[!] --sports</tt>, <tt>--source-ports ''порт''[:''порт''][,''порт''[:''порт''][,...]]</tt> — улучшенная версия критерия <tt>--sport</tt>, описанного выше. Позволяет перечислить (без пробелов, через запятую) до 15 портов или их диапазонов.

<tt>[!] --dports</tt>, <tt>--destination-ports ''порт''[:''порт''][,''порт''[:''порт''][,...]]</tt> — улучшенная версия критерия <tt>--dport</tt>, описанного выше. Например,
<source lang="bash">
iptables -I INPUT -p tcp -m multiport --dport 80,8000:8008 -j ACCEPT
</source>
позволит принимать TCP-пакеты, приходящие на порты 80 и с 8000 по 8008.

<tt>[!] --ports ''порт''[:''порт''][,''порт''[:''порт''][,...]]</tt> — пакет будет подпадать под этот критерий, если его исходный порт ''или'' порт назначения присутствует в указанном списке.

* '''iprange''' — позволяет указать диапазон IP-адресов, не являющийся подсетью. Поддерживает следующие параметры:

<tt>[!] --src-range ''адрес''[-''адрес'']</tt> — позволяет указать диапазон исходных адресов. Например,
<source lang="bash">
iptables -I INPUT -m iprange --src-range 192.168.0.8-192.168.0.25 -j DROP
</source>
заблокирует все пакеты, исходный адрес которых лежит в диапазоне с 192.168.0.8 по 192.168.0.25 включительно.

<tt>[!] --dst-range ''адрес''[-''адрес'']</tt> — позволяет указать диапазон адресов назначения.

==== Критерии маркировки ====

* '''mark''' — позволяет выделять пакеты с заданной маркировкой (nfmark). Имеет единственную опцию

<tt>[!] --mark ''значение''[/''маска'']</tt> — указывает значение маркировки. Простейший пример:
<source lang="bash">
-m mark --mark 15
</source>
будет выделять пакеты с маркировкой 15.

Если указана маска, то перед сравнением с заданным значением маркировка каждого пакета комбинируется с этой маской посредством логической операции AND, то есть проверяется условие <tt>x & ''маска'' == ''значение''</tt> (где x — маркировка текущего пакета). Такой подход позволит сравнивать значения отдельных битов. Например, критерию
<source lang="bash">
-m mark --mark 64/64
</source>
будет отлавливать пакеты, в маркировке которых установлен 7-й бит (<math>2^6=64</math>, при этом первый бит соответствует <math>2^0</math>). В частности, 64…127, 192…255, 320…383 и т. д.

Еще один пример —
<source lang="bash">
-m mark --mark 2/3
</source>
будет определять пакеты, в маркировке которых установлен второй бит, но снят первый. Такие числа будут нацело делиться на два, но не делиться на четыре — 2, 6, 10, 14, …

* '''connmark''' — полностью аналогичен mark, но проверяет не маркировку пакета (nfmark), а маркировку соединения (ctmark). Также имеет параметр <tt>--mark</tt> с аналогичным синтаксисом.

В качестве практического примера использования меток пакетов и соединений рассмотрим улучшение работы l7-filter-userspace.

Userspace-вариант l7-filter является демоном, взаимодействующим с netfilter через подсистему nfnetlink_queue — действие NFQUEUE в терминологии iptables. При помощи этого действия определенные пакеты можно направить на анализ демону l7-filter. По результатам анализа демон выставит маркировку пакетов: 1 — пакет принадлежит новому соединению, тип которого пока не идентифицирован; 2 — пакет принадлежит соединению, тип которого идентифицировать так и не удалось. Другие значения соответствуют установленным типам соединений (соответствие задается в конфигурационном файле демона) [http://l7-filter.sourceforge.net/HOWTO-userspace#Does].

Задача l7-filter — определить тип протокола прикладного уровня (см. модель OSI) для данного пакета/соединения. Решается эта задача путем анализа содержимого пакета с применением регулярных выражений, позволяющих определить типовые лексемы, характерные для различных протоколов (например, «<tt>220 ftp server ready</tt>» для FTP или «<tt>HTTP/1.1 200 OK</tt>» для HTTP). Пакет, в котором встречаются такие лексемы, может быть однозначно классифицирован. В принципе, это дает достаточное основание классифицировать соединение в целом. Однако, в этом поведение kernel и userspace версий l7-filter существенно различается.

Как описывается в [http://l7-filter.sourceforge.net/technicaldetails документации], версия l7-filter-kernel ''хранит'' данные о соединениях и ''использует'' их для классификации пакетов, принадлежащих к соединениям, тип которых уже установлен. В то же время, аналогичное утверждение в отношении l7-filter-userspace в документации отсутствует. И, как показывает практика, userspace-версия ''не использует'' информацию о соединениях. Возможно, это обусловлено техническими ограничениями nfnetlink_queue как средства взаимодействия l7-filter с системой netfilter.

Описанный недостаток значительно снижает эффективность l7-filter — ведь однозначно классифицированы могут быть всего несколько пакетов из каждого соединения, а всего в соединении могут быть миллионы и миллиарды пакетов. Соответственно, применение l7-filter по своему основному назначению — классификация трафика для последующего шейпинга — не оправдывает себя.

Итак, рассмотрим, как, используя возможности netfilter, можно исправить этот недостаток.

Идея решения проста: после обработки пакетов демоном l7-filter, нужно добавить операции по переносу маркировки пакета на соединение (чтобы классифицировать соединение в целом) и с соединения на пакеты (чтобы пометить уже ''все'' пакеты в соединении для дальнейшей обработки шейпером, так как шейпер воспринимает только метки пакетов). Таким образом, классификация одного пакета в соединении влечет классификацию всех последующих пакетов.

Для начала, запустим демон l7-filter-userspace. Небольшое замечание: в его конфигурационном файле (назовем его, например, <tt>l7-filter.conf</tt>) будем помечать протоколы метками в диапазоне от 16 до 31 включительно (почему — станет понятно из дальнейших пояснений).
<source lang="bash">
l7-filter -f /etc/l7-filter.conf -q 2 -m 0x1f
</source>
Параметр <tt>-f</tt> указывает путь к конфигурационному файлу, <tt>-q</tt> — номер очереди, <tt>-m</tt> — задает биты маркировки, модифицируемые демоном l7-filter (в нашем случае — с первого по пятый, что соответствует диапазону значений маркировки от 0 до 31).

Далее, добавим правила, направляющие весь входящий и исходящий трафик (кроме локального) на анализ демону l7-filter:
<source lang="bash">
iptables -t mangle -F # На всякий случай очищаем таблицу mangle
# Направляем на анализ входящий трафик, включая транзитный
iptables -t mangle -A PREROUTING ! -i lo -j NFQUEUE --queue-num 2
# Направляем на анализ исходящий трафик, кроме транзитного
iptables -t mangle -A OUTPUT ! -o lo -j NFQUEUE --queue-num 2
</source>
Добавлять второе из этих правил в цепочку POSTROUTING не стоило — ведь в нее попадает как трафик, исходящий от самого хоста, так и транзитный трафик, который уже был обработан ранее, в цепочке PREROUTING. Посмотрев на диаграмму выше, вы можете убедиться, что приведенные правила обрабатывают весь трафик, как принадлежащий самому хосту, так и транзитный, за исключением локального. Локальный трафик (идущий через интерфейс lo), бессмысленно шейпить, а значит, не стоит и классифицировать.

Теперь добавим правила, обеспечивающие копирование маркировки пакетов в маркировку соединений и обратно:
<source lang="bash">
# Для входящего трафика (кроме транзитного)
# Копируем маркировку пакетов в маркировку соединений
iptables -t mangle -A INPUT -m mark --mark 0x10/0xfffffff0 -j CONNMARK --save-mark
# И наоборот
iptables -t mangle -A INPUT -m connmark --mark 0x10/0xfffffff0 -j CONNMARK --restore-mark
# Аналогично для исходящего трафика (включая транзитный)
iptables -t mangle -A POSTROUTING -m mark --mark 0x10/0xfffffff0 -j CONNMARK --save-mark
iptables -t mangle -A POSTROUTING -m connmark --mark 0x10/0xfffffff0 -j CONNMARK --restore-mark
</source>
Поясним два момента. Во-первых, добавление этих правил в цепочки PREROUTING и OUTPUT, сразу после правил, передающих трафик демону l7-filter, не имеет смысла — после обработки пакетов демон [http://l7-filter.sourceforge.net/HOWTO-userspace#Does применяет] к ним действие ACCEPT, прекращающее обработку пакета в рамках исходных цепочек. Поэтому мы добавляем эти правила в цепочки, идущие «ниже по течению». Как вы можете заметить по диаграмме выше, такая комбинация правил также обеспечивает обработку всего трафика.

Второй момент, который стоит пояснить — маски специального вида. По сути, они позволяют проверить, лежит ли маркировка пакета в диапазоне от 16 до 31. Такая защита позволяет избежать обработки маркировок 0 (такую маркировку имеет локальный трафик, так как он не проходит процедуру анализа), 1 и 2 (эти значения маркировки, как уже было замечено выше, означают, что тип пакета не определен), а также 32 и выше (эти значения мы оставляем для других задач).

Как показывает [http://www.linux.org.ru/jump-message.jsp?msgid=3790164&cid=3791754 практика], даже в самом примитивном случае (детекция протокола HTTP, сервер — nginx 0.6.32, клиент — [http://www.hping.org/wbox/ wbox] 4), эффективность детекции возрастает — без использования маркировки соединений регистрируются лишь 2 исходящих пакета (l7-filter работает на сервере), с использованием — 3 исходящих и 2 входящих. Детальное исследование показывает, что детекции избегают лишь первые четыре пакета в соединении — 2 SYN-пакета и 2 пакета с данными. Это цифры, характерные для тестовой задачи — при передаче больших объемов данных количество детектированных пакетов будет значительно больше, в то время как количество не определенных пакетов сохранит тот же порядок.

Более того, предложенный метод решает задачу, не решенную даже в реализации l7-filter-kernel — маркировка связанных соединений. Согласно документации iptables, маркировка соединений автоматически копируется с исходных соединений на связанные с ними (например, с управляющего FTP-соединения на соединение данных).

: ''Примечание: следующий пример планируется к переносу в еще не написанный раздел статьи (Прочие критерии → statistic)''.

В качестве практического примера использования меток пакетов и соединений можно рассмотреть задачу стохастической балансировки соединений между несколькими аплинками.
Допустим, у нас есть три провайдера, подключенных к интерфейсам eth0, eth1 и eth2 (это могут быть и VLAN-порты одного интерфейса, суть от этого не меняется, только названия), и их шлюзы имеются соответственно IP-адреса 208.77.188.1, 208.77.189.1, 208.77.190.1.

Для начала, создадим для каждого провайдера свою таблицу маршрутизации
<source lang="bash">
echo -e "\n110\tstatic\n111\tprov1\n112\tprov2\n113\tprov3" >> /etc/iproute2/rt_tables
</source>

Этот код добавит в конец файла <tt>/etc/iproute2/rt_tables</tt> строки
110 static
111 prov1
112 prov2
113 prov3
устанавливающие соответствие между внутренними номерами таблиц маршрутизации и их символьными именами. Используемые здесь имена prov1, prov2 и prov3, разумеется, условны. Таблица static — особая, ее мы рассмотрим чуть ниже.

Обратите внимание, что это действие выполняется только один раз — не надо повторять его при каждой загрузке системы!

Далее, сделаем каждого провайдера шлюзом по умолчанию в «своей» таблице:
<source lang="bash">
ip route add default via 208.77.188.1 dev eth0 table prov1
ip route add default via 208.77.189.1 dev eth1 table prov2
ip route add default via 208.77.190.1 dev eth2 table prov3
</source>

Добавим для каждой таблицы правило, отправляющее в нее пакеты с соответствующей маркировкой:
<source lang="bash">
ip rule add fwmark 1 table prov1
ip rule add fwmark 2 table prov2
ip rule add fwmark 3 table prov3
# Но прежде всего пакеты должны пройти таблицу static
ip rule add table static prio 1
</source>

Таблица static предназначена для обслуживания статических маршрутов. В частности, в нее мы занесем подсети провайдеров (предположим, что все они класса 1C), а также наши внутренние локальные сети (если таковые есть):
<source lang="bash">
# Провайдеры
ip route add 208.77.188.0/24 dev eth0 table static
ip route add 208.77.189.0/24 dev eth1 table static
ip route add 208.77.190.0/24 dev eth2 table static
# Две наших локалки
ip route add 192.168.1.0/24 dev eth3 table static
ip route add 192.168.2.0/24 dev eth4 table static
# Сбрасываем кеш маршрутов
ip route flush cache
</source>
Таким образом, если нашему хосту нужно будет обратиться в подсеть провайдера prov2 (208.77.189.0/24), то маршрут пойдет сразу через интерфейс eth1. Также в этой таблице присутствуют маршруты для наших внутренних локальных сетей — с ними тоже все просто.

По сути дела, таблица static обычно содержит те же маршруты, что и таблица main (главная таблица маршрутизации), за исключением маршрута по умолчанию — таких маршрутов у нас несколько и каждый из них размещается в отдельной таблице, выбор между которыми осуществляется на основании назначенной iptables/netfilter маркировки.

Заметим, что ни в таблицу static, ни в какие-либо другие таблицы не нужно вносить loopback-маршруты, например «127.0.0.1/8 dev lo», так как все эти маршруты фигурируют в автоматически создаваемой таблице local, которую любой пакет проходит в первую очередь (нетрудно убедиться в этом, посмотрев вывод команды «ip rule show»).

Далее, отключим статическую антиспуфинговую фильтрацию:
<source lang="bash">
sysctl net.ipv4.conf.all.rp_filter=0
</source>
Reverse path filtering — штука, конечно, удобная и полезная но, к сожалению, совершенно не совместимая с динамической маршрутизацией.

Если вы планируете использовать этот компьютер не только как шлюз, и но и как интернет-сервер (то есть предоставлять доступ к нему извне), необходимо выполнить привязку входящих соединений к их интерфейсам — в противном случае могут возникнуть проблемы, если обращение извне придет через одного провайдера, а сервер ответит через другого.
<source lang="bash">
iptables -t mangle -N bind_connect # Создаем отдельную цепочку (для простоты управления)
# Следите за правильным соответствием значений меток и интерфейсов!
iptables -t mangle -A bind_connect -i eth0 -j CONNMARK --set-mark 1
iptables -t mangle -A bind_connect -i eth1 -j CONNMARK --set-mark 2
iptables -t mangle -A bind_connect -i eth2 -j CONNMARK --set-mark 3
# Пропускаем через эту процедуру все новые соединения к нашему серверу
iptables -t mangle -I INPUT -m conntrack --ctstate NEW -j bind_connect
</source>
Теперь, в сочетании с операцией <tt>-j CONNMARK --restore-mark</tt>, которой мы подвергнем исходящий с нашего сервера трафик (см. ниже), эта процедура обеспечит корректную обработку входящих соединений. (Отметим, что, если бы нам не нужно было бы балансировать исходящие соединения, мы могли бы обойтись вообще без помощи iptables/netfilter, выполнив привязку входящих соединений через правила вида <tt>ip rule add from 208.77.188.100 table prov1</tt> и т.п. — ответные пакеты всегда уходят с того же адреса, на который пришел запрос, так что в качестве критерия для выбора шлюза можно использовать исходный адрес.)

Ввиду того, что выбор исходящего адреса для каждого нового соединения осуществляется на основании правил статической маршрутизации (таблица main), могут возникнуть ошибки. Например, если в маршруте по умолчанию (default) в таблице main указан интерфейс eth0, то все исходящие от нас во внешнюю сеть (интернет) соединения будут иметь в качестве исходного адреса первый адрес интерфейса eth0, и ответные пакеты пойдут именно на этот интерфейс. Чтобы избежать возникновения таких ситуаций, добавим маскарадинг для всех исходящих соединений (предполагается, что у всех провайдеров наши внешние адреса имеют вид 208.77.x.100):
<source lang="bash">
iptables -t nat -A POSTROUTING -o eth0 -j SNAT --to-source 208.77.188.100
iptables -t nat -A POSTROUTING -o eth1 -j SNAT --to-source 208.77.189.100
iptables -t nat -A POSTROUTING -o eth2 -j SNAT --to-source 208.77.190.100
</source>

А теперь — самое интересное. Используя описанный ниже критерий statistic, мы будем случайно распределять метки между пакетами.
<source lang="bash">
iptables -t mangle -N select_prov # Создаем для этого специальную цепочку
iptables -t mangle -A select_prov -j CONNMARK --set-mark 1 # Ставим всем соединениям маркировку 1
iptables -t mangle -A select_prov -m statistic --mode random --probability 0.34 -j RETURN # С вероятностью 34% выходим из этой цепочки
iptables -t mangle -A select_prov -j CONNMARK --set-mark 2 # Ставим всем оставшимся соединениям маркировку 2
iptables -t mangle -A select_prov -m statistic --mode random --probability 0.5 -j RETURN # С вероятностью 50% выходим из этой цепочки
iptables -t mangle -A select_prov -j CONNMARK --set-mark 3 # Всем, кто дошел досюда, ставим маркировку 3
</source>
Первое правило в этой цепочке пройдут все пакеты, вошедшие в нее. После этого, 34 % (примерно треть из них) покинет цепочку согласно второму правилу. Далее, оставшиеся пакеты (66 % от первоначального количества) получат маркировку 2. После этого половина из них (то есть 33 % от начального) покинут цепочку с этой маркировкой. Оставшаяся половина (тоже 33 % от начального количества) получат маркировку 3.

После этого, создадим вспомогательную цепочку, осуществляющую маркировку соединений и пакетов:
<source lang="bash">
iptables -t mangle -N sort_connect
iptables -t mangle -A sort_connect -o lo -j RETURN # Локальным соединениям балансировка не нужна
# Аналогично выгоняем пакеты, выходящие через интерфейсы внутренней локалки, если она есть
iptables -t mangle -A sort_connect -o eth3 -j RETURN
iptables -t mangle -A sort_connect -o eth4 -j RETURN
iptables -t mangle -A sort_connect -m conntrack --ctstate NEW -j select_prov # Все новые пакеты прогоняем через процедуру случайного выбора
iptables -t mangle -A sort_connect -j CONNMARK --restore-mark # Копируем маркировку соединений на пакеты
</source>
Через цепочку <tt>select_prov</tt> мы прогоняем только новые пакеты, то есть первые пакеты каждого соединения. После этой процедуры соединение уже имеет маркировку. К сожалению, на данный момент роутинговая подсистема ядра Linux не умеет маршрутизировать пакеты на основании маркировки соединения — только на основании маркировки пакетов. Поэтому действием <tt>CONNMARK --restore-mark</tt> мы копируем маркировку соединений в маркировку пакетов.

Осталось только добавить вызов этой цепочки в таблицу mangle:
<source lang="bash">
iptables -t mangle -I OUTPUT -j sort_connect
</source>
Теперь все ваши исходящие соединения будут балансироваться согласно описанным правилам.

Аналогичную функциональность можно реализовать и для транзитных соединений. Для этого достаточно добавить вызов <tt>sort_connect</tt> в цепочку FORWARD таблицы mangle:
<source lang="bash">
iptables -t mangle -I FORWARD -j sort_connect
</source>

Разумеется, при этом должна быть разрешена передача транзитного трафика, как в таблице filter, так и на уровне sysctl. Как это делается — см. выше.

Заметим, что кроме алгоритма случайной балансировки, критерий statistic позволяет реализовать балансировку в режим round robin. Для этого поменяем цепочку <tt>select_prov</tt> следующим образом:
<source lang="bash">
iptables -t mangle -F select_prov # Очищаем ее
iptables -t mangle -A select_prov -j CONNMARK --set-mark 1 # Ставим всем соединениям маркировку 1
iptables -t mangle -A select_prov -m statistic --mode nth --every 3 -j RETURN # Первый из трех пакетов - выходим
iptables -t mangle -A select_prov -j CONNMARK --set-mark 2 # Ставим всем оставшимся соединениям маркировку 2
iptables -t mangle -A select_prov -m statistic --mode nth --every 2 -j RETURN # Один из оставшихся двух - выходим
iptables -t mangle -A select_prov -j CONNMARK --set-mark 3 # Последний
</source>

Подробнее о принципах работы критерия statistic см. ниже.

В завершение нашего обсуждения стоит заметить, что в некоторых случаях для балансировки соединений достаточно единственной команды
<source lang="bash">
ip route add default scope global nexthop via 208.77.188.1 dev eth0 weight 1 nexthop via 208.77.189.1 dev eth1 weight 1 # И т.д.
</source>
Стоит обратить особое внимание на тот факт, что данный метод балансирует ''пакеты'', а не соединения. Например, в том случае, если вы хотите организовать выход в интернет из локальной сети через нескольких провайдеров, не имея единого внешнего адреса, этот метод может работать некорректно — часть пакетов пройдет через одного провайдера и после операции NAT получит один исходный адрес, часть пойдет через другого и соответственно получит другой адрес, и в результате удаленные хосты не смогут правильно обрабатывать соединения, исходящие из вашей сети. Однако, в большинстве случаев этот негативный эффект нивелируется другим фактором — кэшированием маршрутов. При прохождении через такое правило серии пакетов, адресованных некоторому хосту, действительно случайным выбор будет только для первого из них, после чего выбранный маршрут будет закэширован, и остальные пакеты к этому хосту будут маршрутизироваться через тот же шлюз. С одной стороны, подобный эффект позволяет соединениям корректно функционировать, с другой стороны — балансировка оказывается не такой уж и случайной. К тому же, после очистки кэша маршрутов (например, посредством ввода команды <tt>ip route flush cached</tt>), работа существующих на этот момент соединений может быть нарушена. В качестве наиболее безопасного и целесообразного применения описанного метода можно привести задачу балансировки транзитного трафика в сетях без NAT (условия «прямой видимости» между балансирующим маршрутизатором и точкой схождения потоков трафика). В том случае, если доступ к шлюзам осуществляется через один сетевой интерфейс, этим методом можно балансировать и соединения, исходящие от самого хоста.

Также заметим, что описанные в этом примере методы балансировки не учитывают загруженность каналов. Для этого рекомендуется использовать критерий rateest и действие RATEEST совместно с уже знакомым нам CONNMARK.

==== Лимитирующие критерии ====

К этой группе относятся критерии, позволяющие ограничивать количество пакетов, соединений, и переданных байт.

* '''limit''' — позволяет ограничить количество пакетов в единицу времени. Параметры:

<tt>--limit ''количество''[/second|/minute|/hour|/day]</tt> — задает ограничение на количество пакетов в секунду (second), минуту (minute), час (hour) или сутки (day). Пакеты в пределах этого количества считаются удовлетворяющими критерию, сверх этого количества — не удовлетворяющими.

<tt>--limit-burst ''количество''</tt> — задает длину очереди, то есть максимальную пропускную способность.

Критерий -limit использует модель «дырявого ведра», и --limit-burst задает «объем ведра», а --limit — «скорость вытекания». Каждому такому критерию соответствует своя очередь, длина которой задается параметром --limit-burst. Если в очереди есть пакеты, то со скоростью, заданной в --limit, они покидают очередь и считаются удовлетворяющими критерию. Если же вся очередь занята, то новые пакеты в ней не регистрируются и считаются ''не'' удовлетворяющими критерию.
Например,
<source lang="bash">
iptables -I INPUT -m limit --limit 3/min --limit-burst 5 -j LOG --log-level debug --log-prefix "INPUT packet: "
</source>
предполагает очередь на пять пакетов, которая «продвигается» со скоростью 3 пакета в минуту. При непрерывном поступлении входящих пакетов, очередь всегда будет заполнена, и в лог будут заноситься в среднем по три пакета в минуту. Однако, если входящих пакетов долго не будет, то очередь успеет очиститься, и при поступлении пяти и менее новых пакетов, они пойдут в лог подряд. В любом случае, скорость попадания пакетов в лог остается неизменной.

Типичная ошибка новичков — использовать limit для ограничения TCP-трафика, например, так:
<source lang="bash">
iptables -A INPUT -p tcp --dport 80 -m limit --limit 10000/sec --limit-burst 10000 -j ACCEPT
iptables -P INPUT DROP
</source>
Это пример попытки защитить web-сервер от DDoS-атаки, ограничив количество пакетов в единицу времени. Однако, это правило не помешает без особого труда завалить сервер запросами (считая, что на один запрос требуется два входящих пакета — SYN-пакет и пакеты данных, содержащий, например, только GET /, согласно спецификации HTTP 0.9). При этом могут возникнуть помехи для легальных пользователей, например, загружающих на сервер большой файл методом POST. Более корректным решением будет ограничивать не скорость входящего потока данных, а скорость открытия новых соединений:
<source lang="bash">
iptables -A INPUT -p tcp --dport 80 -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT
iptables -A INPUT -p tcp --dport 80 -m conntrack --ctstate NEW -m limit --limit 32/sec --limit-burst 32 -j ACCEPT
iptables -P INPUT DROP
</source>
Теперь мы ограничиваем количество не всех пакетов, а только новых, то есть мы разрешаем открывать не более 32 новых соединений в секунду. Впрочем, число 32 приведено здесь только для примера. Конкретное значение скорости для вашей задачи рекомендуем определять самостоятельно.

* '''hashlimit''' — позволяет применять ограничения, аналогичные критерию limit, к группам хостов, подсетей или портов, используя всего одно правило. При этом для каждого хоста, подсети или порта создается отдельная очередь. Можно задвать, например, такие критерии:

«1000 пакетов в секунду с каждого хоста из подсети 192.168.0.0/16»
<source lang="bash">
-s 192.168.0.0/16 -m hashlimit --hashlimit-upto 1000/sec --hashlimit-mode srcip
</source>

«100 пакетов в секунду с каждого TCP-порта хоста 192.168.1.1»
<source lang="bash">
-s 192.168.1.1 -m hashlimit --hashlimit-upto 100/sec --hashlimit-mode srcport
</source>

«10000 пакетов в минуту с каждой подсети префикса 28 (маска 255.255.255.240) из диапазона 10.0.0.0/8»
<source lang="bash">
-s 10.0.0.0/8 -m hashlimit --hashlimit-upto 10000/min --hashlimit-mode srcip --hashlimit-srcmask 28
</source>

Обратите внимание, что в ''каждом'' из этих правил нужно обязательно указать имя таблицы очередей (haslimit-name, см. ниже), однако, в целях простоты изложения, в некоторых примерах этот параметр опущен.

Рассмотрим основные параметры этого критерия более подробно:

<tt>--hashlimit-mode {srcip|srcport|dstip|dstport}[,...]</tt> — задает список контролируемых параметров: адреса (ip) и порты (port) источника (src) и назначения (dst). Например, если указать параметр
<source lang="bash">
--hashlimit-mode srcip,dstip
</source>
то будет создаваться отдельная очередь для каждой пары «адрес источника — адрес назначения», то есть ограничение будет вводиться на количество пакетов, передаваемых с каждого хоста на другой хост (разумеется, если эти пакеты идут через наш сервер). Или, например,
<source lang="bash">
--hashlimit-mode srcip,srcport
</source>
будет создавать отдельную очередь для каждого исходного порта каждого хоста.

<tt>--hashlimit-upto ''количество''[/second|/minute|/hour|/day]</tt> — этот параметр задает скорость движения очереди (аналог <tt>--limit</tt>). Если пакеты поступают с такой же или меньшей скоростью, они считаются подпадающими под критерий. Обратите внимание, что этот параметр ''не'' поддерживает логической инверсии (отрицания) через восклицательный знак (см. ниже).

<tt>--hashlimit-above ''количество''[/second|/minute|/hour|/day]</tt> — этот параметр таке задает скорость движения очереди, но смысл его противоположный — если пакеты поступают с ''большей'' скоростью, они считаются подпадающими под критерий.

<tt>--hashlimit-burst ''количество''</tt> — задает длину каждой очереди. Аналогичен <tt>--limit-burst</tt>.

<tt>--hashlimit-srcmask ''префикс''</tt> — задает размер подсети исходных адресов, для которой вводится своя очередь. Имеет смысл, только если в haslimit-mode указан режим srcip. Как уже говорилось выше,
<source lang="bash">
-m hashlimit --hashlimit-mode srcip --hashlimit-srcmask 28
</source>
будет заводить отдельную очередь для каждой подсети с маской 255.255.255.240 (подробнее про префиксы и маски см. CIDR).
По умолчанию 32 (своя очередь для каждого отдельного хоста). Если указать 0, то контроль по параметру srcip теряет смысл.

<tt>--hashlimit-dstmask ''префикс''</tt> — задает размер подсети исходных адресов, для которой вводится своя очередь. Имеет смысл, только если в haslimit-mode указан режим dstip. Принцип использования аналогичен hashlimit-srcmask.

<tt>--hashlimit-name ''имя''</tt> — позволяет использовать несколько независимых таблиц очередей (hashes), распознаваемых по имени. Обязательный параметр. Например,
<source lang="bash">
iptables -F INPUT # Очищаем цепочку INPUT
iptables -A INPUT -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT # Пропускаем все, что идет по уже установленным соединениям
# Вводим ограничения для новых подключений по FTP
iptables -A INPUT -m conntrack --ctstate NEW -p tcp --dport 21 -m hashlimit --hashlimit-upto 5/min --hashlimit-mode srcip --hashlimit-name ftphash -j ACCEPT
# Вводим ограничения для новых подключений по rsync.
iptables -A INPUT -m conntrack --ctstate NEW -p tcp --dport 873 -m hashlimit --hashlimit-upto 5/min --hashlimit-mode srcip --hashlimit-name rsynchash -j ACCEPT
iptables -P INPUT DROP # Всех остальных не пускаем
</source>
Теперь очереди ограничений для подключения к службам FTP и rsync для нашего сервера будут вводиться независимо, то есть если какой-либо хост превысит предел подключений по FTP, то это никак не повлияет на подключения по rsync. Заметим, что в данном конкретном случае аналогичную функциональность можно реализовать, даже не используя разные хеши:
<source lang="bash">
iptables -F INPUT # Очищаем цепочку INPUT
iptables -A INPUT -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT # Пропускаем все, что идет по уже установленным соединениям
# Вводим ограничения для новых подключений по FTP и rsync
iptables -A INPUT -m conntrack --ctstate NEW -p tcp -m multiport --dport 21,873 -m hashlimit --hashlimit-upto 5/min --hashlimit-mode srcip,dstport --hashlimit-name ftprsynchash -j ACCEPT
iptables -P INPUT DROP # Всех остальных не пускаем
</source>
Впрочем, выбирая между этими двумя реализациями, стоит учитывать, что размер каждого хеша ограничен.

Не забывайте указывать имя таблицы очередей при каждом использовании критерия hashlimit. Если вы не планируете совместно использовать одни и те же таблицы в нескольких правилах, эти имена должны различаться.

Доступ к таблицам очередей возможен через procfs (файл <tt>/proc/net/ipt_hashlimit/имя_таблицы</tt>). Подробнее о формате этого файла можно почитать [http://www.opennet.ru/base/net/iptables_tbf.txt.html здесь], однако учтите, что большая часть сведений, приведенных в указанной статье, устарела.

Критерий haslimit также имеет ряд параметров, не описанных здесь (максимальный размер таблицы, время жизни записи в таблице, интервал «сбора мусора», и т. п.). За подробными сведениями обратитесь к документации.

* '''connlimit''' — позволяет ограничивать количество одновременно открытых соединений с каждого IP-адреса (или подсети). Параметры:

<tt>[!] --connlimit-above количество</tt> — минимальное количество соединений. Все пакеты, проходящие по соединениям, установленным сверх заданного количества, считаются удовлетворяющими критерию. Например,
<source lang="bash">
iptables -A INPUT -p tcp --dport 80 -m connlimit --connlimit-above 3 -j DROP
iptables -A INPUT -p tcp --dport 80 -j ACCEPT
</source>
разрешит не более трех одновременных соединений к нашему веб-серверу с одного IP-адреса. Аналогичного эффекта можно добиться командами
<source lang="bash">
iptables -A INPUT -p tcp --dport 80 -m connlimit ! --connlimit-above 3 -j ACCEPT
iptables -A INPUT -p tcp --dport 80 -j DROP
</source>

<tt>--connlimit-mask</tt> — маска подсети, для которой устанавливается общее ограничение на количество соединений. Например,
<source lang="bash">
iptables -A INPUT -p tcp --dport 80 -m connlimit --connlimit-above 5 --connlimit-mask 24 -j DROP
iptables -A INPUT -p tcp --dport 80 -j ACCEPT
</source>
разрешит не более пяти одновременных соединений на порт 80 с каждой подсети класса 1C.

Не надо путать connlimit с hashlimit — hashlimit позволяет ограничить ''скорость'' поступления пакетов с хостов или подсетей (в сочетании с <tt>-m conntrack --ctstate NEW</tt> — скорость открытия новых соединений), а connlimit — ''количество'' одновременно открытых соединений.

* '''connbytes''' — позволяет ограничивать количество переданных байт или пакетов. Параметры:

<tt>[!] --connbytes ''мин'':[''макс'']</tt> — собственно задает количество пакет или байт. Можно указать просто минимальное количество или диапазон.

<tt>--connbytes-dir {original|reply|both}</tt> — задает направление движения пакетов. Проверяются только пакеты, движущиеся от инициатора соединения к отвечающему (original), наоборот (reply) или в обоих направлениях (both).

<tt>--connbytes-mode {packets|bytes|avgpkt}</tt> — задает собственно учитываемую величину: количество пакетов (packets), количество байт (bytes) или средний размер пакета (avgpkt).

Пример:
<source lang="bash">
# Для соединений, по которым передано более 500 КБ, ставим минимальный приоритет TOS (требование максимальной полосы)
iptables -t mangle -I INPUT -m connbytes --connbytes 512000: --connbytes-dir both --connbytes-mode bytes -j TOS --set-tos Maximize-Throughput
iptables -t mangle -I OUTPUT -m connbytes --connbytes 512000: --connbytes-dir both --connbytes-mode bytes -j TOS --set-tos Maximize-Throughput
# Для соединений, по которым передано менее 50 КБ, ставим максимальный приоритет TOS (требование минимальной задержки)
iptables -t mangle -I INPUT -m connbytes ! --connbytes 51200: --connbytes-dir both --connbytes-mode bytes -j TOS --set-tos Minimize-Delay
iptables -t mangle -I OUTPUT -m connbytes ! --connbytes 51200: --connbytes-dir both --connbytes-mode bytes -j TOS --set-tos Minimize-Delay
</source>
Таким образом, все пакеты, принадлежащие «легким» соединениям, будут маркироваться как наиболее приоритетные, а пакеты, проходящие по «тяжеловесным» соединениям — как наименее приоритетные. Такой подход позволит рационально распределять канал между различными задачами, например, просмотром веб-страниц («легкие» соединения) и скачиванием файлов («тяжелые» соединения).

Конечно, при таком подходе даже «тяжелые» соединения будут занимать канал с наивысшим приоритетом, пока не превысят ограничение. Но даже на медленных соединениях (128 Кбит/с) для этого достаточно всего четырех секунд (если эта закачка в данный момент единственная). После превышения лимита 50 Кбайт соединение получит средний приоритет (TOS не установлен), а еще через некоторое время соединение превысит второй лимит — 500 Кбайт, и получит минимальный приоритет. В то же время, «легкие» соединения в большинстве случаев не превышают даже первого лимита, и поэтому целиком проходят с повышенным приоритетом.

* '''quota''' — позволяет задать квоту в байтах для данного конкретного правила. Имеет единственный параметр

<tt>--quota количество_байт</tt> — собственно задает квоту.

Для каждого правила, содержащего такой критерий, создается счетчик, который уменьшается с каждым прошедшим по этому правилу пакетом на количество байт, равное размеру этого пакета. Когда значение счетчика доходит до нуля, правило перестает срабатывать. Чтобы восстановить счетчик, удалите правило и добавьте его снова.

Например:
<source lang="bash">
sysctl net.ipv4.ip_forward=1 # Разрешаем шлюзу передавать транзитный трафик
iptables -F FORWARD # Очищаем цепочку FORWARD
iptables -A FORWARD -m quota --quota 1073741824 -j ACCEPT
iptables -P FORWARD DROP
</source>
разрешает хосту передавать не более одного гигабайта транзитного трафика (учитывается трафик в обоих направлениях).

* '''quota2''' — критерий из уже упоминавшегося набора xtables-addons. Является результатом развития идей, заложенных в критерии quota. Позволяет создавать именованные счетчики квот (для совместного использования одного счетчика в нескольких правилах), считать не только байты, но и пакеты, а также создавать отдельные правила для пакетов, превышающих квоту (логическая инверсия параметра <tt>--quota</tt>). Поддерживаются следующие параметры:

<tt>--name ''имя''</tt> — задает имя счетчика. Текущее значение счетчика содержится в файле <tt>/proc/net/xt_quota/''имя''</tt>. Его можно вывести на экран
<source lang="bash">
cat /proc/net/xt_quota/имя
</source>
или задать вручную
<source lang="bash">
echo значение > /proc/net/xt_quota/имя
</source>
Для осуществления этих действий, как и для работы с iptables, нужны полномочия суперпользователя.

<tt>[!] --quota ''количество''</tt> — проверяет текущее значение счетчика и уменьшает его на размер текущего пакета. Этот же параметр задает начальное значение счетчика (если счетчик с таким именем уже существует, он не сбрасывается). Пакет считается подпадающим под критерий, если счетчик еще не дошел до нуля (при указании логической инверсии — наоборот). Если немного усложнить наш предыдущий пример,
<source lang="bash">
sysctl net.ipv4.ip_forward=1 # Разрешаем шлюзу передавать транзитный трафик
iptables -F FORWARD # Очищаем цепочку FORWARD
# Устанавливаем квоту для первой подсети
iptables -A FORWARD -s 192.168.1.0/24 -m quota2 --name first --quota 1073741824 -j ACCEPT
# Для тех, кто идет из первой подсети сверх квоты - блокируем и сообщаем об отказе.
# Кстати, счетчик first уже создан, поэтому теперь в параметре quota можно писать любое число. Но мы все-таки напишем 1 Гб.
iptables -A FORWARD -s 192.168.1.0/24 -m quota2 --name first ! --quota 1073741824 -j REJECT
# Устанавливаем квоту для второй подсети
iptables -A FORWARD -s 192.168.2.0/24 -m quota2 --name second --quota 536870912 -j ACCEPT
iptables -P FORWARD DROP
</source>
Теперь для подсети 192.168.1.0/24 установлена квота в 1 Гб, и при превышении этой квоты пакеты блокируются, причем их отправителям хост отвечает пакетами icmp-port-unreachable, уведомляя их, что передача данных заблокирована. Для подсети 192.168.2.0/24 устанавливается квота 512 Мб, и при ее превышении никаких сообщений не посылается (пакеты блокируются «молча»). Так же молча блокируются транзитные пакеты из всех остальных подсетей.

<tt>--packets</tt> — при указании этого параметра счетчик учитывает количество пакетов, а не их суммарный размер.

<tt>--grow</tt> — ''увеличивает'' счетчик, вместо того, чтобы уменьшать его. Критерий с этим параметром всегда возвращает истину. Позволяет создавать счетчики «приходно-расходного типа». Например,
<source lang="bash">
-A INPUT -p tcp --dport 6881 -m quota2 --name bt --grow
-A OUTPUT -p tcp --sport 6881 -m quota2 --name bt
</source>
позволяет в любой момент определять разность сумм входящих (на TCP-порт 6881) и исходящих (с этого же порта) байт через файл <tt>/proc/net/xt_quota/bt</tt>.

Вот [http://jengelh.medozas.de/2009/0717-bandwidth-monitoring.php еще один пример] использования этого критерия для сбора статистики по трафику.

Обратите внимание, что при указании параметра grow критерий quota2 ''всегда'' будет возвращать истину. Действие для такого правила обычно назначать не имеет смысла — правило изменяет только счетчик квоты, а не сам пакет.

* '''length''' — позволяет использовать в качестве критерия размер пакета. Проверятся размер пакета протокола транспортного уровня (TCP, UDP, SCTP, DCCP и т. д.) или, иначе говоря, размер пакета протокола сетевого уровня (IP, IPv6) за вычетом размера заголовков сетевого уровня. Данный критерий имеет единственный параметр

<tt>[!] --length ''размер''[:''макс_размер'']</tt>, который может употребляться в нескольких формах:

: <tt>--length ''размер''</tt> — пакет проверяется на точное соответствие заданному размеру,

: <tt>--length ''мин_размер'':</tt> — размер пакета должен быть больше или равен заданной величине,

: <tt>--length :''макс_размер''</tt> — размер пакета должен быть меньше или равен заданной величине,

: <tt>--length ''мин_размер'':''макс_размер''</tt> — размер пакета должен попадать в указанный диапазон (включая границы).

Смысл всех приведенных форм может быть заменен на противоположный, как обычно, указанием перед данным параметром восклицательного знака. Все размеры задаются в байтах.

В качестве практического примера использования данного критерия можно рассмотреть установку высокого приоритета TOS (требование минимальной задержки) для небольших транзитных пакетов (размер до 512 байт):
<source lang="bash">
iptables -t mangle -I INPUT -m length --length :512 -j TOS --set-tos Minimize-Delay
</source>

* '''length2''' — расширение критерия length, доступное в наборе xtables-addons. Отличается от классического length возможностью проверять размеры пакетов на различных уровнях модели OSI. Принимает следующие опции:

<tt>--layer3</tt> — проверка размера пакета сетевого уровня (например, IPv4-пакета).

<tt>--layer4</tt> — проверка размера пакета транспортного уровня (например, TCP-пакета).

<tt>--layer5</tt> — проверка размера полезной нагрузки транспортного уровня (например, содержимого TCP-пакета, ''не'' учитывая размер заголовков TCP). Работает корректно только для некоторых протоколов транспортного уровня, на момент написания этих строк (конец 2009) поддерживаются: TCP, UDP, UDPLite, ICMP, ICMPv6, DCCP, SCTP, IPSec(AH и ESP). Для SCTP-пакета в этот размер включаются все секции (chunks) вместе с их заголовками.

<tt>--layer7</tt> — для SCTP проверяется суммарный размер DATA-секций в пакете (то есть его полезная нагрузка), для остальных протоколов аналогично <tt>--layer5</tt>.

По умолчанию используется <tt>--layer3</tt>, однако во избежание недоразумений рекомендуется явно указывать одну из перечисленных опций. Если этого не делать, при вводе соответствующей команды появится сообщение
iptables: length match: Defaulting to --layer3. Consider specifying it explicitly.
Это ''не'' является ошибкой (только предупреждением о возможной неоднозначности). Заданное вами правило должно добавиться успешно.

<tt>[!] --length ''размер''[:''макс_размер'']</tt> — собственно, задает нужные значения размера. В отличие от аналогичного параметра в классическом критерии length, его синтаксические формы несколько беднее. Допускаются два варианта записи:

: <tt>--length ''размер''</tt> — пакет проверяется на точное соответствие заданному размеру,

: <tt>--length ''мин_размер'':''макс_размер''</tt> — размер пакета должен быть попадать в указанный диапазон (включая границы).

Впрочем, недостающие варианты легко выразить через имеющиеся: для имитации <tt>--length :''макс_размер''</tt> используйте <tt>--length 0:''макс_размер''</tt>, а вместо <tt>--length ''мин_размер'':</tt> применяйте <tt>--length ''мин_размер'':65535</tt>.

Будьте внимательны: в отличие от length, length2 не проверяет взаимное соответствие границ диапазона (<tt>''мин_размер'' <= ''макс_размер''</tt>), и если вы зададите их неправильно (<tt>''мин_размер'' > ''макс_размер''</tt>), ваше правило просто никогда не будет срабатывать. 

'''Подводя краткий итог по разделу «Лимитирующие критерии»''', хотелось бы заметить, что перечисленные в этом разделе критерии предназначены главным образом для ограничения доступа и защиты от различных атак. Не стоит пытаться ограничивать с их помощью трафик. Для ограничения и приоритезации трафика в Linux рекомендуется использовать стандартный шейпер ядра, управляемый при помощи утилиты tc.


==== Критерий recent ====

recent — это специальный критерий, позволяющий запоминать проходящие через него пакеты, а затем использовать полученную информацию для принятия решений. Ввиду его уникальности, широких возможностей и, как следствие, некоторых трудностей в понимании новичками принципов его использования, рассказ о нем был вынесен в отдельный подраздел.

Если быть точным, recent запоминает не сами пакеты, а их количество, время поступления, адрес источника (в последних версиях iptables также может запоминать и адрес назначения), а также, при необходимости, TTL.

В начале кратко рассмотрим его опции:

<tt>[!] --set</tt> — запомнить адрес источника/назначения пакета (внести его во внутренний список). Если такая запись уже присутствует в списке — обновить время последнего доступа для нее. Обратите внимание, что критерию recent с опцией <tt>--set</tt> удовлетворяют ''все'' пакеты. Чтобы ему не удовлетворял ни один пакет — используйте логическую инверсию (<tt>! --set</tt>).

<tt>[!] --rcheck</tt> — позволяет проверить, присутствует ли адрес источника/назначения пакета во внутреннем списке. Критерий recent с этой опцией вернет истину, если адрес в списке присутствует.

<tt>[!] --update</tt> — работает аналогично <tt>--rcheck</tt>, но еще и обновляет время последнего доступа для данной записи.

<tt>[!] --remove</tt> — работает аналогично <tt>--rcheck</tt>, но еще и удаляет найденную запись из списка. Если запись не найдена, пакет считается ''не'' соответствующим критерию.

<tt>--seconds ''число''</tt> — дополнительная опция в режимах <tt>--rcheck</tt> и <tt>--update</tt>. Пакет считается соответствующим критерию, только если последний доступ к записи был не позднее, чем ''число'' секунд назад.

<tt>--hitcount ''число''</tt> — дополнительная опция в режимах <tt>--rcheck</tt> и <tt>--update</tt>. Пакет считается удовлетворяющим критерию, если было не менее ''число'' обращений к данной записи. Обычно используется вместе с <tt>--seconds</tt> — тогда критерий имеет смысл «не менее n обращений за последние m секунд».

Заметим, что, хотя в официальной документации для параметров <tt>--seconds</tt> и <tt>--hitcount</tt> указывается возможность отрицания (указания перед ними восклицательного знака), на самом деле такое отрицание никак не обрабатывается в коде и не меняет смысла параметров, так что указывать его бессмысленно. Эта ошибка в документации исправлена в версии iptables 1.4.7.

<tt>--rttl</tt> — дополнительно к адресу источника/назначения, заносить в список и проверять еще и TTL пакета.

<tt>--rsource</tt> — эта опция появилась в последних версиях iptables, с тех пор, как критерий recent начал поддерживать запоминание адресов не только источника, но и назначения. Позволяет явно указать, что в список вносится именно адрес источника пакета. Однако в целях обратной совместимости этот режим используется по умолчанию, и поэтому указывать данную опцию не обязательно.

<tt>--rdest</tt> — эта опция появилась в последних версиях iptables. Позволяет явно указать, что в список вносится именно адрес назначения пакета.

<tt>--name ''имя''</tt> — позволяет указать имя списка при использовании нескольких списков. По умолчанию используется список DEFAULT. Каждый список представлен псевдофайлом <tt>/proc/net/xt_recent/''имя''</tt> (на старых ядрах критерий recent реализован только для IPv4, но не для IPv6, поэтому вместо <tt>xt_recent</tt> будет <tt>ipt_recent</tt>). В частности, вы можете:
<source lang="bash">
cat /proc/net/xt_recent/имя # вывести список на экран
echo +адрес > /proc/net/xt_recent/имя # добавить адрес в список
echo -адрес > /proc/net/xt_recent/имя # удалить адрес из списка
echo / > /proc/net/xt_recent/имя # очистить список
</source>

Теперь давайте рассмотрим несколько примеров.
* Блокирование bruteforce-атак (подбор пароля вслепую) на [[SSH|Ssh]] и аналогичные сервисы.
<source lang="bash">
iptables -N ssh_brute_check # Создаем цепочку для проверки попыток соединений на защищаемый порт
# Если за последние 10 минут (600 секунд) с одного адреса было 3 или более новых соединений — блокируем этот адрес
iptables -A ssh_brute_check -m conntrack --ctstate NEW -m recent --update --seconds 600 --hitcount 3 -j DROP
# В противном случае — разрешаем, и при этом заносим в список
iptables -A ssh_brute_check -m recent --set -j ACCEPT
iptables -F INPUT # Очищаем цепочку INPUT
iptables -A INPUT -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT # Разрешаем пакеты по установленным соединениям
# Все попытки открыть новое соединение по SSH направляем на проверку
iptables -A INPUT -m conntrack --ctstate NEW -p tcp --dport 22 -j ssh_brute_check
# Здесь можно разрешать те порты, для которых такая проверка не нужна. Например, HTTP
iptables -A INPUT -m conntrack --ctstate NEW -p tcp --dport 80 -j ACCEPT
iptables -P INPUT DROP # Что не разрешено — то запрещено
</source>
Теперь все попытки открыть новое SSH-соединение проверяются, и с одного IP-адреса можно открывать не более 2 соединений за 10 минут. Обратите внимание, что за одно соединение злоумышленник может проверить несколько паролей — число попыток аутентификации до обрыва соединения задает параметр MaxAuthTries в файле <tt>/etc/ssh/sshd_config</tt>. По умолчанию это число равно 6, так что в нашем примере злоумышленник сможет проверять не более 12 паролей за 10 минут.

Впрочем, данный пример весьма тривиален, и сходную функциональность можно получить и при помощи критерия hashlimit:
<source lang="bash">
iptables -A INPUT -m conntrack --ctstate NEW -p tcp --dport 22 -m hashlimit --hashlimit-mode srcip --hashlimit-upto 5/hour --hashlimit-name ssh -j ACCEPT
</source>
разрешит не более 5 новых соединений в час.
Данная реализация имеет недостаток по сравнению с recent — вы не можете произвольно задавать временной период.

* Защита от сканирования портов (заметим, что кроме критерия recent для этой задачи можно также использовать критерии psd и lscan из комплекта xtables-addons).
<source lang="bash">
iptables -F INPUT # Очищаем цепочку INPUT
iptables -A INPUT -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT # Разрешаем пакеты по установленным соединениям
# Если за последний час было 10 или более запросов на нерабочие порты — блокируем
iptables -A INPUT -m recent --rcheck --seconds 3600 --hitcount 10 --rttl -j RETURN
# Если за последнюю минуту было 2 или более запросов на нерабочие порты — блокируем
iptables -A INPUT -m recent --rcheck --seconds 60 --hitcount 2 --rttl -j RETURN
# Разрешаем рабочие порты
iptables -A INPUT -m conntrack --ctstate NEW -p tcp -m multiport --dport 21,25,53,80,110 -j ACCEPT
iptables -A INPUT -m conntrack --ctstate NEW -p udp -m multiport --dport 53,123 -j ACCEPT
# Всех, кто ломится в нерабочие порты — регистрируем
iptables -A INPUT -m recent --set
iptables -P INPUT DROP # Что не разрешено — то запрещено
</source>
Все пакеты, попадающие на нерабочие порты сервера, регистрируются. После нескольких таких попыток за заданный интервал времени адрес их источника блокируется. Проверка TTL добавлена для защиты от блокировки легитимных клиентов после спуфинга злоумышленником от их имени. Хотя, с другой стороны, эта мера позволяет ему обойти защиту от сканирования, выставляя своим пакетам различный TTL. Так что вопрос о нужности этой проверки в вашем конкретном случае вам придется решать самостоятельно.

Другой пример использования критерия recent для детекции и блокирования сканирования портов:
<source lang="bash">
# Создаем цепочку для проверки и блокирования портсканов
iptables -N portscan_check
# Блокируем тех, кто был уличен в портскане в течение последних суток
iptables -A portscan_check -m recent --name portscan --rcheck --seconds 86400 -j DROP
# По прошествии суток можно удалять их из списка
iptables -A portscan_check -m recent --name portscan --remove
# Ну а сейчас — собственно процедура определения портскана
iptables -A portscan_check -p tcp --dport 139 -m recent --name portscan --set -j DROP
# Пускаем на проверку всех, кто пришел к нам из интернета (интерфейс eth0)
iptables -I INPUT -i eth0 -j portscan_check
</source>
В данном случае сканированием портов считается обращение на порт 139/tcp (SMB). Впрочем, вы можете задать другой порт или, используя критерий multiport, даже список портов. В отличие от предыдущего примера, здесь производится автоматическая очистка списка IP-адресов: по прошествии суток с момента блокировки, первое же обращение с заблокированного адреса на наш сервер приводит к удалению этого адреса из нашего recent-списка. Однако, если это обращение вновь является попыткой сканирования портов, то есть направлено на порт 139/tcp, адрес тут же блокируется вновь. Именно поэтому процедура блокировки расположена «ниже по течению», чем процедура удаления адреса из списка.

Для предыдущего примера реализация очистки списка адресов достигается следующим образом:
<source lang="bash">
# Создаем цепочку для проверки на необходимость удаления
iptables -N recent_remove
# Последнее обращение на неиспользуемые порты было менее суток назад
# поэтому оставим-ка пока этот адресок в черном списке
iptables -A recent_remove -m recent --rcheck --seconds 86400 -j RETURN
# Если адрес в есть в списке — удаляем его оттуда
iptables -A recent_remove -m recent --remove
# Вставляем эту проверку вторым правилом (сразу после проверки ctstate)
iptables -I INPUT 2 -j recent_remove
</source>

Проводя аналогию с ныне почившим проектом [http://www.opennet.ru/docs/RUS/portsentry/portsentry-security.html.gz PortSentry], первый наш пример соответствует режиму PortSentry «Advanced Stealth Scan Detection», а второй — «Enhanced Stealth Scan Detection». (Правда, заметим, что в режиме Advanced Stealth Scan Detection блокировка производится после ''первого'' попадания пакета на нерабочий порт — для достижения такого же эффекта в нашем примере достаточно выкинуть проверки на seconds и hitcount из блокирующих правил.) Однако, использование iptables/recent имеет значительное преимущество перед примитивными userspace-системами наподобие PortSentry — возможность интеграции с системой conntrack, что позволяет избежать ошибочной блокировки, например, при использовании высоких портов для NAT.

* Открытие порта «по стуку».

Port knocking — метод защиты портов, при котором доступ к определенному порту с отдельно взятого IP-адреса открывается после серии пакетов на заданную последовательность портов с заданными интервалами.  Обычно эта задача решается при помощи демона knockd либо критерия pknock из комплекта xtables-addons.

Несколько самых простых вариантов такой защиты можно организовать и средствами критерия recent.

Самое простое — открывать порт ssh (22) после стука в заданный высокий порт:
<source lang="bash">
iptables -N ssh_knock # Создаем цепочку для проверки попыток соединений на защищаемый порт
# Если за последние 60 секунд было 2 и более стука — блокируем, на всякий случай
iptables -A ssh_knock -m recent --rcheck --seconds 60 --hitcount 2 -j RETURN
# Если за последние 10 секунд стук в нужный порт был — разрешить соединение
iptables -A ssh_knock -m recent --rcheck --seconds 10 -j ACCEPT
iptables -F INPUT # Очищаем цепочку INPUT
iptables -A INPUT -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT # Разрешаем пакеты по установленным соединениям
# Все попытки открыть новое соединение по SSH направляем на проверку
iptables -A INPUT -m conntrack --ctstate NEW -p tcp --dport 22 -j ssh_knock
# Здесь мы добавляем правило для регистрации стука
iptables -A INPUT -m conntrack --ctstate NEW -p tcp --dport 27520 -m recent --set
# Опять же на всякий случай — при стуке в соседние порты закрываем SSH
iptables -A INPUT -m conntrack --ctstate NEW -p tcp -m multiport --dport 27519,27521 -m recent --remove
iptables -P INPUT DROP # Что не разрешено — то запрещено
</source>
Даже в таком простом примере присутствуют жесткие меры защиты: защищаемый порт (22) открывается на 10 секунд после стука в заданный порт (27520), при этом более одного стука в этот порт в течение минуты считается ошибкой. Также стук в соседние с заданным порты сразу закрывает защищаемый порт. Это делается в целях защиты от подбора стука.

Если вам не интересны такие параноидальные меры безопасности, то обратите внимание на этот простой пример:
<source lang="bash">
iptables -N ssh_knock # Создаем цепочку для проверки
# Если за последние 10 минут было 5 и более попыток соединения — блокируем
iptables -A ssh_knock -m recent --name ssh --update --seconds 600 --hitcount 5 -j RETURN
# Регистрируем
iptables -A ssh_knock -m recent --name ssh --set
# Если за последние 5 секунд было менее двух попыток — блокируем
iptables -A ssh_knock -m recent --name ssh ! --rcheck --seconds 5 --hitcount 2 -j RETURN
# Все остальное — разрешаем
iptables -A ssh_knock -j ACCEPT
iptables -F INPUT # Очищаем цепочку INPUT
iptables -A INPUT -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT # Разрешаем пакеты по установленным соединениям
# Все попытки открыть новое соединение по SSH направляем на проверку
iptables -A INPUT -m conntrack --ctstate NEW -p tcp --dport 22 -j ssh_knock
iptables -P INPUT DROP # Что не разрешено — то запрещено
</source>
Идея метода проста: защищаемый порт открывается со второй попытки, то есть стук идет непосредственно в него. Вторую попытку нужно сделать в течение 5 секунд после первой. При этом 5 и более попыток за десять минут блокируются (во избежание брутфорса).

Также можно организовать защиту через стук в серию портов:
<source lang="bash">
iptables -N reset_knock # Цепочка для сброса процесса стука
iptables -A reset_knock -m recent --name PHASE1 --remove
iptables -A reset_knock -m recent --name PHASE2 --remove
iptables -A reset_knock -m recent --name PHASE3 --remove
iptables -A reset_knock -m recent --name PHASE4 --remove
iptables -N in_phase_2 # Создаем цепочку для фазы 2
iptables -A in_phase_2 -m recent --name PHASE1 --remove # Удаляем запись из списка первой фазы
iptables -A in_phase_2 -m recent --name PHASE2 --set # Добавляем ее в список второй фазы
iptables -N in_phase_3 # Создаем цепочку для фазы 3
iptables -A in_phase_3 -m recent --name PHASE2 --remove # Удаляем запись из списка второй фазы
iptables -A in_phase_3 -m recent --name PHASE3 --set # Добавляем ее в список третьей фазы
iptables -N in_phase_4 # Создаем цепочку для фазы 4
iptables -A in_phase_4 -m recent --name PHASE3 --remove # Удаляем запись из списка третьей фазы
iptables -A in_phase_4 -m recent --name PHASE4 --set # Добавляем ее в список четвертой фазы
iptables -N checked # Для записей, прошедших проверку
iptables -A checked -j reset_knock # Очищаем списки
iptables -A checked -j ACCEPT # Разрешаем пакет
iptables -F INPUT # Очищаем цепочку INPUT
iptables -A INPUT -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT # Разрешаем пакеты по установленным соединениям
# Первая фаза
iptables -A INPUT -p tcp --dport 21210 -m recent --name PHASE1 --set -j RETURN
# Для тех, кто присутствует в списке первой фазы — переход во вторую
iptables -A INPUT -p tcp --dport 11992 -m recent --rcheck --name PHASE1 --seconds 5 -g in_phase_2
# И т.д.
iptables -A INPUT -p tcp --dport 16043 -m recent --rcheck --name PHASE2 --seconds 5 -g in_phase_3
iptables -A INPUT -p tcp --dport 23050 -m recent --rcheck --name PHASE3 --seconds 5 -g in_phase_4
# Если стучатся не в том порядке — сброс
iptables -A INPUT -p tcp -m multiport --dport 21210,11992,16043,23050 -j reset_knock
# Для тех, кто прошел все четыре фазы — разрешаем доступ
iptables -A INPUT -p tcp --dport 22 -m conntrack --ctstate NEW -m recent --rcheck --name PHASE4 --seconds 5 -j checked
iptables -P INPUT DROP # Дефолтное правило цепочки INPUT
</source>
Принцип прост — при стуке в порт, соответствующий очередной фазе, проверяется наличие записи в предыдущей фазе. Теперь порт 22 откроется на 5 секунд после стука в порты 21210, 11992, 16043, 23050 со строгим соблюдением порядка перечисления и интервалами не более 5 секунд.

Обратите внимание на технику реализации процесса — цепочки фаз вызываются не через <tt>-j</tt>, а через <tt>-g</tt>, поэтому после прохождения этих цепочек к пакетам сразу применяется правило по умолчанию цепочки INPUT, то есть DROP. В противном случае пакеты доходили бы до правила сброса (которое с multiport), и процесс стука все время сбрасывался бы.

Последовательный стук в порты можно организовать, например, утилитой netcat
<source lang="bash">
for it in {21210,11992,16043,23050}; do
echo " " | nc -w 1 host $it
done
ssh user@host
</source>

Другие примеры реализации port knocking’а при помощи критерия recent можно посмотреть на [http://wiki.opennet.ru/Iptables_-m_recent OpenNet wiki], [http://www.debian-administration.org/articles/268 debian-administration.org], [http://silverghost.org.ua/2007/06/13/ssh-portknocking/ silverghost.org.ua], [http://www.opennet.ru/openforum/vsluhforumID3/41732.html#32 форуме OpenNet].

==== Критерий u32 ====

Данный критерий предоставляет очень гибкий инструмент, позволяющий производить сложные операции по анализу содержимого пакета. Алгоритм обработки содержимого исследуемого пакета задается на специальном языке программирования, своеобразном «ассемблере». Такой подход позволяет получить огромную гибкость, но при этом его изучение и использование может представлять определенные трудности для пользователей, не знакомых с основами программирования и принципами работы машины Тьюринга.

Этот критерий имеет единственный параметр — <tt>[!] --u32</tt>, после которого в двойных кавычках записывается текст «программы». Если все проверки, заданные в программе, дают истинный результат, пакет считается удовлетворяющим данному критерию. Традиционно, если перед параметром указан восклицательный знак, означающий логическое отрицание, то удовлетворяющими критерию считаются только те пакеты, для которых хотя бы одна проверка дала ложный результат.

Ключевые операторы языка критерия u32:
* '''=''' — оператор сравнения. Собственно, на его основе и формируются все производимые проверки. Синтаксис его вполне очевиден: <tt>выражение = значение</tt>. В качестве значения можно использовать одно число, диапазон (в формате <tt>мин:макс</tt>) или список чисел и/или диапазонов разделенных запятой (например, <tt>1,3:5,8,11:14</tt>). В одном списке можно указывать не более 10 чисел/диапазонов.
* '''&&''' — оператор логического И, объединяющий все производимые в программе проверки. В одном критерии u32 можно указывать не более 10 таких проверок. Обратите внимание, что операция логического ИЛИ отсутствует, так как это противоречит идеологии iptables (в каждом правиле все проверки объединяются логическим И, а логическое ИЛИ объединяет правила в одной цепочке).
* '''&''' — оператор побитового логического И, позволяющий применить к обрабатываемому значению битовую маску.
* '''<<''' и '''>>''' — операторы побитового сдвига влево и вправо соответственно. Эквивалентны домножению или делению обрабатываемого значения на 2 в соответствующей степени. Обратите внимание, что в одном выражении для проверки можно использовать не более 9 операторов &, << и >>.
* '''@''' — оператор задания смещения. Добавляет результат предыдущего выражения к текущему значению начального смещения (в начале работы программы, до выполнения @-операций, начальное смещение считается нулевым). Очень полезен в тех случаях, когда нужно сместиться на некоторое значение, полученное в результате обработки пакета, например, узнав после некоторых вычислений длину IP-заголовка, мы можем сместиться на данные непосредственно после него, т.е. на начало полезной нагрузки IP-пакета (как правило, там находится заголовок транспортного уровня).

Все операторы имеют равный приоритет, исполнение операций всегда происходит слева направо.

Обратите внимание, что программа рассматривает все значения как целые беззнаковые величины, заданные 32 битами, или четырьмя октетами (что соответствует значениям от 0 до 4294967295). Именно поэтому критерий имеет такое название (u32 — unsigned 32-bit).

Другой не вполне очевидный момент — синтаксис операторов =, &, << и >>. Дело в том, что в качестве первого операнда указывается не само значение, а его ''адрес'' в пределах пакета, заданный смещением в байтах от текущего начального смещения. Например, <tt>8 = 0x12345678</tt> означает, что нужно взять четыре байта, начиная с восьмого (обратите внимание, что нумерация байтов в пакете начинается с нуля), т.е. байты 8, 9, 10 и 11, и сравнить полученное значение с шестнадцатеричным числом 0x12345678. Как уже говорилось, критерий u32 ''всегда'' манипулирует блоками по четыре байта, поэтому, если вас интересуют блоки меньшего размера, используйте оператор & и маску, например, <tt>8 & 0xFF = 0x78</tt> позволяет проверить только последний в блоке (11-й от начального смещения) байт. Также можно использовать и оператор смещения, например, <tt>8 >> 24 = 0x12</tt> возьмет первый в блоке (8-й от начального смещения) байт и сравнит его с числом 0x12. Более подробно о битовых операциях можно почитать в соответствующей статье.

Рассмотрим возможности критерия u32 на нескольких простых примерах из официальной документации:
* Проверить, превышает ли длина пакета величину 256 байт: <tt>--u32 "0 & 0xFFFF = 0x100:0xFFFF"</tt>.
Эта программа предписывает взять четыре байта, начиная с нулевого, затем занулить первые два байта (в них содержится информация о версии протокола, длине заголовка и типе обслуживания, которая нас сейчас не интересует), и проверить значение, формируемого оставшимися двумя байтами (это и есть полная длина пакета в байтах) на принадлежность диапазону от 0x100 (256 в десятичном счислении) до 0xFFFF (65535, максимально возможная длина пакета).
* Проверить, является ли данный пакет ICMP-пакетом с типом 0 (эхо-ответ). Учитывая переменную длину IP-заголовка, эта проверка требует несколько большего количества операций: <tt>--u32 "6 & 0xFF = 1 && 4 & 0x3FFF = 0 && 0 >> 22 & 0x3C @ 0 >> 24 = 0"</tt>
Рассмотрим эти операции последовательно:
:*'''6 & 0xFF = 1''' — проверка кода протокола. Код протокола хранится в 9-м (считая с нуля) байте IPv4-заголовка. Чтобы получить это значение, мы берем 4-х байтовый блок с шестого по девятый байт, а затем при помощи маски выделяем последний, интересующий нас байт в это блоке, и сравниваем его с единицей (код протокола ICMP).
:*'''4 & 0x3FFF = 0''' — проверка, не является ли наш пакет фрагментом. Фрагменты ICMP-пакетов не содержат ICMP-заголовка, в котором должен храниться тип ICMP, поэтому для них дальнейшая проверка не имеет смысла. Пользуясь описанным выше принципом, наша программа выделяет последние 14 бит в блоке с 4-го по 7-й байт, и сравнивает полученное значение с нулем. Строго говоря, для наших целей достаточно было бы и 13 бит (маска 0x1FFF), выделяющих только поле смещения фрагмента (fragment offset, оно должно быть равным нулю для первого пакета в цепочке фрагментов), а использование 14 бит, как это сделано в примере из официальной документации, также захватит и флаг MF (more fragments), что отсечет вообще все фрагментированные пакеты, даже те, которые являются первыми в последовательности и содержат все нужные нам заголовки.
:*'''0 >> 22 & 0x3C @''' — определение длины IP-заголовка в байтах. Последние четыре бита в первом байте IP-пакета показывают длину IP-заголовка в блоках по четыре байта. Смещая это значение на 22 позиции вправо, мы оставляем справа «зазор» в два бита, которые впоследствии зануляем при помощи маски (3C16 = 1111002). Также эта маска отсекает лишние биты слева (версия протокола). Полученные два нулевых бита справа соответствуют умножению на четыре, так что в результате мы получаем длину заголовка уже в байтах. Например, если длина IP-заголовка составляет 5 четырехбайтовых блоков (т.е. 20 байт), то изначально первый блок заголовка имеет вид <tt>xxxx0101 yyzzzzzz uuuuuuuu uuuuuuuu</tt> (где биты <tt>xxxx</tt> задают версию протокола, 01012=510 — собственно длину заголовка, <tt>yyzzzzzz</tt> — тип обслуживания, а два байта <tt>uuuuuuuu uuuuuuuu</tt> показывают полную длину пакета вместе с нагрузкой), то после смещения вправо на 22 бита мы получим в этом блоке следующую картину: <tt>00000000 00000000 000000xx xx0101yy</tt>. После применения маски она пример вид <tt>00000000 00000000 00000000 00010100</tt>. Полученное число — 101002=2010 и будет равно длине заголовка в байтах. Наконец, оператор @ устанавливает полученное значение в качестве начального смещения, поэтому вся дальнейшая адресация ведется уже начиная с начала ICMP-заголовка, который следует непосредственно после IP-заголовка.
:*'''0 >> 24 = 0''' — выделяет блок с нулевого по третий байт ICMP-заголовка, а затем при помощи смещения (на три байта вправо) оставляет от него только один, нулевой, байт, в котором и хранится тип ICMP. Нас интересует тип 0, поэтому мы и сравниваем этот байт с нулем.
* Проверить, задают ли байты с восьмого по одиннадцатый полезной нагрузки TCP-пакета одно из значений: 1, 2, 5, 8. Достигается следующим кодом: <tt>--u32 "6 & 0xFF = 6 && 4 & 0x3FFF = 0 && 0 >> 22 & 0x3C @ 12 >> 26 & 0x3C @ 8 = 1,2,5,8"</tt>
:*'''6 & 0xFF = 6''' — выделение байта с кодом протокола и сравнение его с кодом 6 (соответствует TCP). Описание этой проверки уже приведено при рассмотрении предыдущего примера.
:*'''4 & 0x3FFF = 0''' — проверка, не является ли данный пакет фрагментом. Полностью аналогична описанной в предыдущем примере.
:*'''0 >> 22 & 0x3C @''' — определение длины IP-заголовка в байтах. Также полностью аналогично описанному в предыдущем примере. После данной операции, начальное смещение указывает на нулевой байт TCP-заголовка.
:*'''12 >> 26 & 0x3C @''' — определение длины TCP-заголовка в байтах. Принцип действия аналогичен предыдущей операции, с тем лишь отличием, что длина TCP-заголовка закодирована в первых четырех битах двенадцатого байта (а не в последних четырех битах нулевого байта, как в случае с IP-заголовком), поэтому необходимое нам смещение вправо составляет уже 26 бит. Как и в предыдущей операции, мы оставляем справа зазор в два бита, которые впоследствии зануляем маской, и таким образом сразу получаем длину заголовка в байтах. Итак, после второго оператора @, начальное смещение будет указывать на начало полезной нагрузки TCP-пакета (следует непосредственно после заголовка).
:*'''8 = 1,2,5,8''' — эта операция сравнения вполне тривиальна: выделяется четырехбайтовый блок, начиная с восьмого байта (разумеется, считая от начала полезной нагрузки), и полученное значение сравнивается с одним из допустимых по условию задачи.

Также, в качестве полезных примеров использования критерия u32, можно упомянуть проверку портов источника и назначения в протоколе UDPLite: <tt>--u32 "6 & 0xFF = 136 && 4 & 0x3FFF = 0 && 0 >> 22 & 0x3C @ 0 >> 16 = исходный_порт"</tt> и <tt>--u32 "6 & 0xFF = 136 && 4 & 0x3FFF = 0 && 0 >> 22 & 0x3C @ 0 & OxFFFF = порт_назначения"</tt> соответственно (после сказанного выше нетрудно догадаться, что исходный порт указывается в первой паре байт UDPLite-заголовка, а порт назначения — во второй, согласно [http://tools.ietf.org/html/rfc3828 RFC3828]).

==== Прочие критерии ====

==== Критерии из набора xtables-addons ====

== Программы ==

=== Основные ===

==== iptables ====

===== Работа с цепочками =====

iptables [-t table] -N chain

Создать цепочку

iptables [-t table] {-F|-L|-Z} [chain [rulenum]] [options...]

* -F - Удалить все правила из цепочки
* -L - Просмотреть цепочку
* -Z - Обнулить счётчики пакетов в цепочке

iptables [-t table] -P chain target

Установить политику по умолчанию для цепочки

iptables [-t table] -X {chain}

Удалить цепочку. Внимание! На удаляемую цепочку не должно быть ссылок.

===== Работа с правилами =====

iptables [-t table] -I chain [rulenum] rule-specification

Вставить правило в начало цепочки (или в позицию rulenum, считая с 1)

iptables [-t table] -R chain rulenum rule-specification

Заменить правило с номером rulenum на rule-specification

iptables [-t table] {-A|-C|-D} chain rule-specification

* -A - добавить правило в конец
* -С - проверить, что такое правило есть в таблице
* -D - удалить правило по описанию или по rulenum

===== Вывод информации =====

==== iptables-save, iptables-restore и iptables-xml ====

==== /etc/init.d/iptables ====

==== iptables-apply ====

==== ipset ====
ipset работает с типами данных, которые представляют из себя (man ipset):
* bitmap:ip — список IP адресов из определенной подсети
* bitmap:ip,mac — связки IP+MAC
* bitmap:port — список портов
* hash:ip — произвольный набор IP
* hash:net — произвольный набор сетей
* hash:mac
* hash:net,net
* hash:ip,port
* hash:net,port
* hash:ip,port,ip
* hash:ip,port,net
* hash:ip,mark
* hash:net,port,net
* hash:net,iface
* list:set

Пример правила iptables с применением ipset (man iptables-extensions):
iptables -I INPUT 1 -i eth0 -p tcp -m tcp --dport 8080 -m set --match-set test123 src -j ACCEPT

-где test123 это заданное имя сета
ipset create test123 hash:net

=== Вспомогательные ===

==== Полезные при конфигурировании фаервола ====



==== Полезные при тестировании фаервола ====

<blockquote>iptables -L -n -v #Статистика всех правил iptables и счетчики обработанных пакетов 
</blockquote>

== Фронтенды ==

=== С удобным интерфейсом ===

=== С графическим интерфейсомм ===

=== С веб-интерфейсом ===
[http://www.117.su iptadmin] - это пользовательский web интерфейс для iptables, редактор настроек файрволла операционной системы Linux. Реализован в виде отдельного http(s) сервера.

Особенностью программы являются подробные сообщения об ошибках при редактировании правил файрволла.

iptadmin работает на уровне iptables. Настройки файрволла сохраняются в стандартных файлах. В системе не создаются никакие вспомогательные данные. Логика работы спроектирована таким образом, что нарушение целостности конфигурации iptables исключено. Iptadmin можно в любой момент установить или удалить без потери настроек файрволла.

=== Программные интерфейсы ===

== Модули ядра ==

=== Модули conntrack и nat ===

=== Модули критериев и действий ===

== Параметры sysctl/procfs ==

=== Псевдофайлы procfs ===

==== Базовые ====

==== Относящиеся к критериям и действиям ====

=== Основные параметры sysctl ===
ip_forward=1

=== Параметры конфигурации интерфейсов ===

=== Параметры, относящиеся к протоколам ===

==== TCP ====

==== UDP ====

==== ICMP ====

=== Параметры conntrack ===

== Расширения ==

=== Userspace-компоненты ===

==== NuFW ====

==== l7-filter-userspace ====

==== iplist ====

=== Наборы дополнительных критериев и действий ===

==== Patch-o-Matic ====
Смотри на официальном сайте http://www.netfilter.org/projects/patch-o-matic/pom-external.html

==== Patch-o-Matic-NG ====

==== xtables-addons ====

== Команды ==
Программа позволяет задать правила, которым должны соответствовать проходящие через брандмауэр IP-пакеты. Эти правила, как и все настройки Linux, записываются в текстовый файл, находящийся в папке /etc. Последовательность правил называется цепочкой (CHAIN). Для одного и того же сетевого интерфейса используются несколько цепочек. Если проходящий пакет не соответствует ни одному из правил, то выполняется действие по умолчанию.

При вызове, параметром указывается команда, которую нужно выполнить. Обычно можно указать только одну команду (но есть исключения). Команду можно указать одной большой буквой или словом. Если при вызове любой команды не указано название таблицы, то команда выполняется в таблице filter. Программа имеет подробную справку, вызываемую командой ''man iptables''.

;Вывести правила (<tt>-L</tt>, <tt>--list</tt>)
<tt>'''iptables''' [-t ''таблица''] -L [''цепочка''] [''параметры'']</tt>

Вывести список правил для указанной таблицы и цепочки. Если цепочка не указана, то выводятся список правил для каждой цепочки. Например для вывода правил из таблицы nat:
<tt>iptables -t nat -n -L</tt>

Часто используются параметры -n (во избежение медленных запросов DNS) и -v (для вывода более подробной информации).

Команду -L можно использовать с -Z (<tt>iptables -L -Z</tt>) для вывода значений счетчиков и одновременного их обнуления.

;Удалить все правила из цепи (<tt>-F</tt>, <tt>--flush</tt>)
<tt>'''iptables''' [-t ''таблица''] -[F] [''цепочка''] [''параметры'']</tt>

Если цепочка не указана, то удаляются все цепочки из таблицы.

;Обнулить все счетчики (<tt>-Z</tt>, <tt>--zero</tt>)
<tt>'''iptables''' [-t ''таблица''] -Z [''цепочка''] [''параметры'']</tt>

Присваивает счетчикам числа пакетов и объема данных нулевые значения. Если цепочка не указана, то обнуление выполняется для всех цепочек.

Команду -Z можно использовать с -L (<tt>iptables -L -Z</tt>) для вывода значений счетчиков и одновременного их обнуления.

;Создать новую цепочку (<tt>-N</tt>, <tt>--new-chain</tt>)
<tt>'''iptables''' [-t ''таблица''] -N ''цепочка''</tt>

Создать новую цепочку в указанной таблице с указанным именем. Если в указанной таблице уже есть цепочка с указанным именем, то новая не создается.

;Удалить созданную цепочку (<tt>-X</tt>, <tt>--delete-chain</tt>)
<tt>'''iptables''' [-t ''таблица''] -X [''цепочка'']</tt>

Удалить цепочку ранее созданную с помощью команды '''-N'''. Перед удалением цепи необходимо удалить или заменить все правила, которые ссылаются на эту цепочку. Если цепочка не указана, то из таблицы будут удалены все цепи кроме стандартных (INPUT, OUTPUT, FORWARD, PREROUTING, POSTROUTING). Стандартные цепочки не удаляются.

;Переименование цепи (<tt>-E</tt>, <tt>--rename-chain</tt>)
<tt>'''iptables''' [-t ''таблица''] -E ''цепочка'' ''новое_название''</tt>

Присваивает указанной цепочке новое название. Косметическая функция, не влияющая на функциональность.

;Установить политику для стандартной цепи (<tt>-P</tt>, <tt>--policy</tt>)
<tt>'''iptables''' [-t ''таблица''] -P ''цепочка'' ''действие'' [''параметры'']</tt>

Над пакетами которые доходят до конца указанной цепочки будет выполняться указанное действие. В качестве действия нельзя указывать название какой-либо цепочки. Устанавливать политику можно только на встроенных цепочках. Например:
<tt>iptables -P INPUT DROP</tt>

=== Команды модификации правил ===

;Добавить новое правило (<tt>-A</tt>, <tt>--append chain</tt>)
<tt>'''iptables''' [-t ''таблица''] -A ''цепочка'' ''спецификация_правила'' [''параметры'']</tt>

Правило добавляется в конец указанной цепочки. Если в спецификации правила указано имя отправителя или получателя, которое одновременно соответствует нескольким адресам, то в конец цепочки добавляются правила для всех возможных комбинаций.

;Вставить новое правило (<tt>-I</tt>, <tt>--insert</tt>)
<tt>'''iptables''' [-t ''таблица''] -I ''цепочка'' [''номер_правила''] спецификация_правила [''параметры'']</tt>

Указанное правило вставляется в указанное место указанной цепочки. Правила нумеруются с 1, поэтому если указать номер 1 (или не указать вообще), то правило будет вставлено в начало цепочки.

;Удалить правило (<tt>-D</tt>, <tt>--delete</tt>)
<tt>'''iptables''' [-t ''таблица''] -D ''цепочка'' ''номер_правила'' [''параметры'']</tt>

<tt>'''iptables''' [-t ''таблица''] -D ''цепочка'' ''спецификация_правила'' [''параметры'']</tt>

Правило можно указывать при помощи его номера в цепочке (нумерация начинается с 1) или его спецификации.

;Заменить правило (<tt>-R</tt>, <tt>--replace</tt>)
<tt>'''iptables''' [-t ''таблица''] -R ''цепочка'' ''номер_правила'' ''спецификация_правила'' [''параметры'']</tt>

Заменить правило с указанным номером в указанной цепочке. Правила нумеруются с 1. Спецификация правила не может содержать имени отправителя или получателя, которое одновременно соответствует нескольким адресам.

=== Параметры определения правил ===
'''Важно.'''
В последующих версиях описанный ниже синтаксис изменился. Например, старому синтаксису
* <tt>'''-s'''</tt>, <tt>--src</tt>, <tt>--source [!] ''адрес''[/''маска'']</tt>
теперь соответствует новый
* <tt>[!] '''-s'''</tt>, <tt>--src</tt>, <tt>--source ''адрес''[/''маска'']</tt>

Перечисленные ниже параметры используются при задании спецификации правил и указываются с командами модификации правил. Эти параметры ограничивают применение правил — если обрабатываемый пакет не соответствует указанным в спецификации критериям, то указанное в правиле действие на этот пакет не распространяется.

* <tt>'''-p'''</tt>, <tt>--protocol [!] ''протокол''</tt>

Ограничение протокола. Основные значения: <tt>tcp</tt>, <tt>udp</tt>, <tt>icmp</tt>, или <tt>all</tt>. Протокол также можно указать с помощью номера, или названия указанного в файле <tt>/etc/protocols</tt>. Знак «!» перед именем протокола изменяет критерий на противоположенный (например <tt>!tcp</tt> означает «любой протокол, кроме TCP»). Значение «Любой протокол» можно указать с помощью слова <tt>all</tt> или числа 0. Если протокол не указан, то подразумевается «Любой протокол».

* <tt>'''-s'''</tt>, <tt>--src</tt>, <tt>--source [!] ''адрес''[/''маска'']</tt>

Ограничение отправителя. Адрес может быть IP-адресом (возможно с маской), именем хоста, или доменным именем. Маска может быть в стандартном формате (например 255.255.255.0) или же в виде числа, указывающего число единиц с «левой стороны» маски (например 24). Знак «!» перед адресом изменяет критерий на противоположенный.

Настоятельно не рекомендуется использовать имена, для разрешения которых требуется удаленный запрос, например по системе DNS.

* <tt>'''-d'''</tt>, <tt>--dst</tt>, <tt>--destination [!] ''address''[/''mask'']</tt>

Ограничение получателя. Синтаксис такой же, как у --src.

* <tt>'''-i'''</tt>, <tt>--in-interface [!] ''имя_интерфейса''</tt>

Ограничение входящего сетевого интерфейса. Знак «!» перед адресом изменяет критерий на противоположенный. Если указанное имя интерфейса заканчивается на «+», то критерию совпадают все интерфейсы, чьи имена начинаются на указанное имя. Если параметр --in-interface не указан, то критерию соответствуют пакеты из любого сетевого интерфейса.

* <tt>'''-o'''</tt>, <tt>--out-interface [!] ''имя_интерфейса''</tt>

Ограничение выходящего сетевого интерфейса. Синтаксис такой же, как и для --in-interface.

* <tt>[!] '''-f'''</tt>, <tt>--fragment</tt>

Ограничение пр фрагментам: критерию соответствуют только фрагменты пакета, начиная со второго фрагмента. Знак «!» перед адресом изменяет критерий на противоположенный.

У таких фрагментов начиная со второго нет заголовка с портами отправителя и получателя (или с типом ICMP). Следовательно, такие фрагменты не соответствуют критериям, указывающим номера портов.

* <tt>'''-j'''</tt>, <tt>--jump ''действие_или_цепочка''</tt>
* <tt>'''-g'''</tt>, <tt>--goto ''цепочка''</tt>

Спецификация действий и переходов. Если указанно название цепочки ранее созданной командой -N, то пакеты соответствующие критериям правила переносится в начало указанной цепочки (запрещено указывать название цепочки, в котором это правило находится). Если указано действие, то оно выполняется над пакетами соответствующим критериям правила. Если в правиле нет параметров --jump и --goto, то правило не влияет на проверяемые пакеты (но счетчик правила продолжает работать).

--goto отличается от --jump поведением при действии RETURN. Действие RETURN переводит пакет в правило, следующее после того, которое вызвало предыдущий переход --jump. То есть, если пакет перешел из цепочки X в цепочку Y при помощи --jump, а потом в Z опять при помощи --jump, то действие RETURN из цепочки Z возвращает его в Y. Если же пакет перешел в Z при помощи --goto, то RETURN возвращает его в X.

* <tt>'''-c'''</tt>, <tt>--set-counters ''пакеты байты''</tt>

Параметр позволяет при добавлении или изменении правил одновременно инициализировать счетчики числа пакетов и размера данных.
Подстрочный текст

== Модули ==
Кроме фильтров по умолчанию поддерживаются дополнительные модули, подключающиеся автоматически при выборе протокола ('''-p''') или вручную опцией '''-m''' (''--match''), после которой следует имя подключаемого фильтра и его опции. Также как и для остальных правил фильтрации, здесь можно использовать '''!''' в качестве отрицания.

=== Некоторые из встроенных (входящие в стандартный пакет) ===

==== state ====
Соединением для NetFilter является закономерно оформленная последовательность обмена пакетами между хостами, с выделением роли каждого пакета в соединении. Эта особенность позволяет контролировать трафик с точки зрения транспортного уровня (модели OSI). Ядро NetFilter отслеживает соединения и ведёт активное наблюдение за открытием новых, протеканием и завершением установленных соединений. Каждый пакет может быть классифицирован по одному из следующих состояний: NEW, ESTABLISHED, RELATED и INVALID.

NEW — типов пакетов, участвующих в установке нового соединения.

ESTABLISHED — пакет уже установленного соединения

RELATED — Соединение получает статус RELATED если оно связано с другим соединением, имеющим признак ESTABLISHED. Это означает, что соединение получает признак RELATED тогда, когда оно инициировано из уже установленного соединения, имеющего признак ESTABLISHED.

Состояние RELATED относится к служебному трафику, протоколу ICMP стека TCP/IP.

INVALID — неправильный/ошибочный/испорченный пакет. Обычно для таких пакетов применяют действие DROP

ПРИМЕР:

iptables -t nat -A PREROUTING -s 10.10.10.10 -m conntrack --ctstate NEW,INVALID -j DROP

Все новые и ошибочные пакеты, идущие с адреса 10.10.10.10 отбрасываются

==== connlimit ====
Позволяет задавать возможное количество одновременных подключений к машине от заданного IP или блока адресов

<tt>[!] --connlimit-above n</tt> — пакет подойдет под описание, если количество одновременных подключений на данный момент больше (меньше), чем n

<tt>--connlimit-mask bits</tt> — позволяет задать маску блока адресов

iptables -A INPUT -p tcp --syn --dport 80 -m connlimit --connlimit-above 20 -j REJECT --reject-with tcp-reset

==== iprange ====
Выделяет не один адрес, как <tt>--src</tt>, а все адреса от ip1 до ip2

Нужно учитывать тот факт что перед использованием данного критерия, необходимо подгрузить модуль его реализующий «-m iprange»

<tt>[!]--src-range ip1-ip2</tt>

<tt>[!]--dst-range ip1-ip2</tt>

==== multiport ====

Выделяет не один порт, как <tt>--dport</tt> или <tt>--sport</tt>, а несколько по списку (до 15 штук). Можно задавать диапазоны как первый_порт:последний_порт. Может быть использовано только вместе с <tt>-p udp</tt> или <tt>-p tcp</tt>.

<tt>[!]--source-ports port1,port2,port3:port4</tt>

<tt>[!]--destination-ports port1,port2,port3:port4</tt>

<tt>[!]--ports port1,port2,port3:port4</tt>

==== mac ====
Сравнение не IP источника пакета, а его ethernet-адреса

<tt>[!] --mac-source address</tt>. MAC-адрес должен быть указан в стандартном формате XX:XX:XX:XX:XX:XX.

Если нужна фильтрация по MAC-адресу в мостовых соединениях (например, pppoe), то можно воспользоваться утилитой ebtables, которая предназначена как раз для более низкоуровневой фильтрации пакетов.

Фиксируем получение IP-адреса по DHCP не из доверенного источника (MAC-адреса 00:50:8D:FD:E6:32):

iptables -A INPUT -i eth0 -p UDP --sport 68 --dport 67 -m mac ! --mac-source 00:50:8D:FD:E6:32 -m limit --limit 3/minute -j LOG --log-prefix "IPT::DHCP: " --log-level warning
iptables -A INPUT -i eth0 -p UDP --sport 68 --dport 67 -j ACCEPT

== Примечания ==

== Ссылки ==
* https://ru.wikibooks.org/wiki/Iptables
* http://www.netfilter.org/ — Сайт проекта Netfilter
* [http://security.maruhn.com/iptables-manual.html Man page of iptables]
* [http://www.frozentux.net/documents/iptables-tutorial/ Frozentux Iptables Tutorial]
* [http://www.opennet.ru/docs/RUS/iptables Руководство по iptables (Iptables Tutorial 1.1.19)]
* [http://wiki.archlinux.org/index.php/Simple_stateful_firewall_HOWTO#Prerequisites Простой полноценный межсетевой экран (готовый шаблон для дектопа)]
* [http://posix.ru/network/iptables Настройка межсетевого экрана Iptables (готовый шаблон для дектопа)]
* http://freecode.com/projects/flex-fw — гибкая надстройка над iptables для построения сервис-ориентированного statefull-фаервола с простым синтаксисом команд.
* https://help.ubuntu.com/community/IptablesHowTo
* https://help.ubuntu.com/community/UFW
* https://help.ubuntu.com/community/Gufw
* https://help.ubuntu.com/9.10/serverguide/C/firewall.html
* https://wiki.ubuntu.com/UncomplicatedFirewall
* https://help.ubuntu.com/community/Firewall