Язык С не обеспечивает никаких встроенных средств для выполнения таких общих операций как ввод-вывод, управление памятью, обработка строк, и т.п.. Вместо этого, такие средства определены в стандартной библиотеке, которую Вы подключаете к вашим программам.
Библиотека GNU C, описанная в этом документе, содержит описание всех библиотечных функций, которые определены в соответствии c ANSI C стандартом, учитывая дополнительные особенности, специфические для POSIX-стандарта операционной системы UNIX, и расширений, специфических для GNU-разработок.
Цель этого руководства состоит в том, чтобы сообщить Вам, как использовать средства GNU библиотеки. Мы упомянули особенности ее стандартов, чтобы помочь Вам разобраться с вещами, которые являются потенциально непереносимыми на другие системы. Но переносимость не является основным вопросом данного руководства.
Это руководство написано с учетом того, что Вы по крайней мере немного знакомы с языком программирования C и базисными понятиями программирования. Вообще считается, что стандарт ANSI C (см. раздел 1.2.1 [ANSI C]) проще для понимания, чем "традиционные", предшествующие ANSI C, диалекты.
Если Вы читаете это руководство впервые, Вам следует подробно прочитать весь вводный материал, а остальное главы только просмотреть. В библиотеке GNU C имеется множество функций, и Вы не запомните, как использовать каждую из них. Но Вы в общих чертах ознакомитесь с видами средств, которые обеспечивает библиотека, поэтому когда Вы будете писать ваши программы, Вы сможете распознавать, когда использовать библиотечные функции, и где в этом руководстве Вы сможете найти более специфическую информацию по ним.
Этот раздел обсуждает различные стандарты и другие источники, на которых базируется GNU C. Эти источники включают стандарты ANSI и POSIX, а так же реализации System V и Berkeley Unix.
Первичная цель этого руководства - сообщить Вам, как эффективно использовать средства библиотеки GNU. Но если Вас интересует создание ваших программ, совместимых с определенными стандартами, или переносимых на операционные системы отличные от GNU, то оно укажет Вам направление использования библиотеки. Этот раздел дает Вам краткий обзор выше перечисленных стандартов, так, чтобы Вы знали, что они представляют, когда они упоминаются в других частях руководства.
См. Приложение B [Обзор библиотеки], для получения алфавитного списка функций и других символов, обеспечиваемых библиотекой. Этот список указывает также, на какие стандарты опирается каждая функция или символ.
Библиотека GNU C совместима со стандартом C, принятым Американским Институтом Национальных Стандартов (ANSI): American National Standard X3.159-1989_"ANSI C". Заголовочные файлы и библиотечные средства, которые составляют библиотеку GNU - надмножество средств, определенных в соответствии c ANSI C стандартом.
Если Вы следуете относительно строгой приверженности к ANSI C стандарту, Вы должны использовать опцию ` -ansi ', когда Вы компилируете ваши программы компилятором GNU C. Эта опция указывает, чтобы транслятор определил только возможности стандарта ANSI из библиотечных заголовочных файлов, если Вы явно не попросите о дополнительных особенностях, для получения информации относительно того, как это сделать см. раздел 1.3.4 [Макрокоманды установки возможностей].
Способность ограничить библиотеку, чтобы включить только возможности ANSI C важна, потому что ANSI C устанавливает ограничения, которым не удовлетворяют некоторые имена, определяемые библиотечной реализацией, т.е. GNU расширения не всегда удовлетворяют этим ограничениям. См. раздел 1.3.3 [Зарезервированные имена], где приводится более подробная информация относительно этих ограничений.
Это руководство не будет вдаваться в подробности различий между ANSI C и более старыми диалектами. Оно поможет вам написать программы, чтобы работать корректно под многими диалектами С, но не более.
Библиотека GNU также совместима с семейством стандартов IEEE POSIX, известных более формально как Переносной Интерфейс Операционной Системы. POSIX взят в основном из различных версий операционной системы UNIX.
Библиотечные средства, определенные POSIX стандартами надмножество соответствующих cтандарту ANSI C; POSIX определяет дополнительные особенности для функций ANSI С, и задает определения новых дополнительных функций. Вообще предпочтение отдается скорее дополнительным требованиям и функциональным возможностям, определяемым POSIX стандартами, обеспечивающим поддержку низшего уровня для определенной среды операционной системы, чем общей поддержке языка программирования, который может выполняться в многих разнообразных средах операционной системы.
GNU C библиотека осуществляет все функции, определенные в IEEE Std 1003.1-1990, Системе Интерфейса Прикладных программ POSIX, обычно упоминающемся как POSIX.1. Первичные расширения к ANSI C средствам, определенные этими стандартными примитивами интерфейса файловой системы (см. Главу 9 [Интерфейс файловой системы]), зависят от устройства функции управления терминалом (см. Главу 12 [Интерфейс терминала низкого уровня]), и функции управления процессом (см. Главу 23 [Порожденнные процессы]).
Некоторые средства из IEEE Std 1003.2-1992, Стандарта Оболочки и Утилит POSIX (POSIX.2) также представлены в библиотеке GNU. Они включают в себя утилиты для обработки регулярных выражений и других средств сопоставления с образцом (см. Главу 16 [Сопоставления с образцом]).
GNU C библиотека определяет средства (которые формально не стандартизированы) из некоторых версий UNIX: 4.2 BSD, 4.3 BSD, и 4.4 BSD Unix системы (также известной как Berkeley Unix) и из SunOS (популярной 4.2 BSD производной, которая включает некоторые функциональные возможности Unix System V ). Эта система поддерживает большинство ANSI и POSIX средств, 4.4 BSD и более новые выпуски SunOS, т.е. фактически поддерживает их все.
BSD средства включают символические связи (см. раздел 9.4 [Символические связи]), функцию выбора (см. раздел 8.6 [Ожидание ввода вывода]), функции сигнала BSD (см. раздел 21.9 [BSD Обработка сигнала] ), и межпроцессорные связи (см. Главу 11 [Гнезда]).
Описание Интерфейса System V (SVID) - документ, описывающий AT&T операционную систему Unix System V. Это -, в некоторой степени, надмножество стандарта POSIX (см. раздел 1.2.2 [POSIX])
GNU C библиотека определяет некоторых из средств, требуемых SVID, и не требуемых в соответствии c ANSI или POSIX стандартами, для совместимости с Unix System V и другой UNIX системой (типа SunOS), которые включают эти средства. Однако, многие из большего количества менее известных и менее полезных средств, требуемых SVID не включены. (Фактически, Unix System V сама не обеспечивает их все.)
Этот раздел описывает некоторые из практические проблемы использования GNU C библиотек.
Библиотеки используемые С программами на самом деле состоят из двух частей: заголовочные файлы, которые определяют типы и макрокоманды и объявляют переменные и функции; и фактическая библиотека или архив, который содержит определения переменных и функций.
( В Cи, описание просто представляет информацию,что функция или переменная существует, и присваивает ей тип. Для функционального объявления, нужно указать информацию относительно типов параметров. Цель объявлений состоит в том, чтобы транслятор правильно обработал ссылки к объявленным переменным и функциям. С другой стороны, определение фактически распределяет память для переменных или указывает, что делает функция.)
Чтобы использовать средства библиотеки GNU C, Вы должны убедиться, что ваши исходные программы включают соответствующие заголовочные файлы, чтобы транслятор видел объявления доступных средств, и мог правильно обрабатывать ссылки на них. При компиляции вашей программы, компоновщик свяжет эти ссылки с фактическими определениями, находящимися в файле архива.
Файлы заголовка включаются в исходный файл директивой препроцессора "#include". Язык С поддерживает две формы этой директивы; первая,
#include "header"
#include <file.h>
Обычно, директивы "#include" помещены в начале исходного С файла, перед любым другим кодом. Если Вы начинаете ваши исходные файлы некоторыми комментариями, объясняя, что код в файле делает, поместите директивы "#include" сразу после комментариев, согласно особенностям макроопределения (см. раздел 1.3.4 [Особенности макрокоманд] ).
Для получения подробной информации относительно использования заголовочных и директивы "#include" см. раздел "Заголовочные файлы" в Руководстве по препроцессору GNU C.
GNU C библиотека обеспечивает несколько заголовочных файлов, каждый из которых содержит тип, макроопределения, переменную и описания функций для группы связанных средств. Это означает, что в ваши программы следует включить несколько файлов заголовка, в зависимости от того, какие средства Вы используете.
Некоторые библиотечные заголовочные файлы включают другие библиотечные заголовочные файлы. Однако, программируя в хорошем стиле, Вы не должны полагаться на это; лучше явно включить все заголовочные файлы, требуемые для библиотечных средств, которые Вы используете. GNU C библиотека была написана таким способом, что не имеет значения, включен ли заголовочный файл случайно больше чем один раз; при включении заголовочного файла второй раз ничего не происходит. Аналогично, если ваша программа многократно включает заголовочные файлы, порядок включения, не имеет значения.
Примечание относительно совместимости: включение стандартного заголовочного файла в любом порядке и любое число раз работает в любой ANSI C реализации. Однако, этого традиционно не было во многоих более старых C реализациях.
Строго говоря, Вы не должны включать заголовочный файл, чтобы использовать функцию, которую он объявляет; Вы можете объявить функцию явно, согласно спецификациям в этом руководстве. Но обычно лучше включить заголовочный файл, потому что он может определять типы и макрокоманды, которые иначе не доступны, или он может определять более эффективные макро замены для некоторых функций. Это - также верный способ иметь правильное объявление.
Если мы в этом руководстве описываем что-нибудь как функцию, то она может иметь и макроопределение. Обычно это не имеет никакого значение, потому что ваше макроопределение делает ту же самую вещь, что и функция. В частности, макро-эквиваленты для библиотечных функций вычисляют параметры ровно один раз, так же образом, как и при обращение к функции. Основная причина для этих макроопределений состоит в том, что иногда они могутреализовывать встроенное расширение, которое является значительно быстрее, чем фактическое обращение к функции.
Взятие адреса библиотечной функции работает даже, если она определена как макрокоманда, потому что, в этом контексте, имя функции не сопровождается левой круглой скобкой, которая является синтаксически необходимой, чтобы распознать макрообращение.
Вы можете иногда не использовать макроопределение функции, возможно, чтобы сделать вашу программу более простой или для отладки. Имеются два способа, сделать это:
extern int abs ( int);
#include < stdlib.h >
int f ( int * i) {return (abs (++ * i));}
#include < stdlib.h >
int g ( int * i) {return ((abs) (++ * i));}
#undef abs
int h ( int *i) { return (abs (++*i)); }
Имена всех библиотечных типов, макрокоманд, переменных и функций, которые исходят из ANSI C стандарта, зарезервированы безоговорочно; ваша программа не имеет права переопределять эти имена. Все другие библиотечные имена зарезервированы, если ваша программа явно включает заголовочный файл, который определяет или объявляет их. Для этих ограничений имеются несколько причин:
Некоторые дополнительные классы имен идентификатора зарезервированы для будущих расширений языка С. Использовании этих имен для ваших собственных целей прямо сейчас создает возможность конфликта с будущими версиями стандарта C, так что Вам следует избегать этих имен.
Управляя макрокомандами, Вы определяете точный набор особенностей, доступный, когда при компиляции исходного файла.
Если Вы компилируете ваши программы, используя "gcc -ansi", Вы получаете только ANSI C библиотечные особенности, если Вы явно не запрашиваете дополнительные особенности, определяя одну или большее количество макрокоманд особенностей. См. раздел "Опции Команд GNU CC" в GNU CC Руководстве, для уточнения информации относительно опций GCC.
Вы должны определить эти макрокоманды, используя директивы препроцессора "#define" в начале ваших файлов. Эти директивы должны стоять перед любым #include заголовочного файла системы. Лучше всего указывать их самыми первыми в файле, только после комментариев. Вы могли бы также использовать опцию `-D' для GCC, но лучше, если Вы создаете исходные файлы с указанием их собственного значения замкнутым способом.
Если Вы определяете эту макрокоманду, то функциональные возможности из стандарта POSIX.1 (Стандарт ИИЭРа 1003.1) доступны, также как все ANSI C средства.
Если Вы определяете эту макрокоманду со значением 1, то будут определены функциональные возможности из стандарта POSIX.1 (Стандарт ИИЭР 1003.1). Если Вы определяете эту макрокоманду со значением 2, то станут доступны функциональные возможности из стандарта POSIX.1 и функциональные возможности из стандарта POSIX.2 (Стандарт ИИЭР 1003.2). Это - в дополнение к ANSI C средствам.
Если Вы определяете эту макрокоманду, включаются функциональные возможности 4.3 BSD Unix, также как ANSI C, POSIX.1, и POSIX.2.
Некоторые из особенностей происходящие от 4.3 BSD Unix конфликтуют с соответствующими особенностями, определенными стандартом POSIX.1. Если эта макрокоманда определена, 4.3 BSD определения, имеют больший приоритет чем POSIX определения.
Из-за некоторых конфликтов между 4.3 BSD и POSIX.1, Вы должны использовать специальную BSD библиотеку совместимости при компоновании программ, компилируемых для BSD совместимости. Т. к. некоторые функции должны быть определены двумя различными способами, один из них в нормальной библиотеке C, а другой в библиотеке совместимости. Если ваша программа определяет _BSD_SOURCE, Вы должны указать опцию "-lbsd-compat" транслятору или компоновщику при компоновании программы, чтобы он нашел функции в этой специальной библиотеке совместимости перед поиском их в нормальной библиотеке C.
Если Вы определяете эту макрокоманду, функциональные возможности из SVID, включены также как ANSI C, POSIX.1, и POSIX.2.
Если Вы определяете эту макрокоманду, включены все: ANSI C, POSIX.1, POSIX.2, BSD, SVID, и расширения GNU. В случаях, конфликтов POSIX.1 с BSD, POSIX определения берут верх.
Если Вы хотите получить полный эффект _GNU_SOURCE, но установить BSD определениям больший приоритет необходимо примеенить следующую последовательность определений:
#define _GNU_SOURCE
#define _BSD_SOURCE
#define _SVID_SOURCE
Мы рекомендуем, чтобы Вы использовали _GNU_SOURCE в новых программах. Если Вы не определяете опцию `-ansi' для GCC и не определяете никакую из этих макрокоманд явнно, то _GNU_SOURCE дает тот же эффект.
Обратите внимание, что особенности _BSD_SOURCE не подмножество любой другой из обеспечиваемых макрокоманд особенностей. Потому что эта макрокоманда определяет особенности BSD, которые берут верх над особенностями POSIX, которые запрашиваются другими макрокомандами. По этой причине, определение _BSD_SOURCE в дополнение к другим макрокомандам особенностей заставляет особенности BSD брать верх при конфликтое с особенностями POSIX .
Имеется краткий обзор содержания оставшихся глав этого руководства.
Много функций в GNU C библиотеке обнаруживают и выводят ошибки условий, и иногда ваши программы должны проверить эти ошибки условий. Например, когда Вы открываете входной файл, Вы должны проверить, что файл был фактически открыт правильно, и печатать сообщение об ошибках или выполнять другое соответствующее действие, если обращение к библиотечной функции потерпело неудачу.
Эта глава описывает, как работают средства сообщений об ошибках. Чтобы использовать эти средства, ваша программа должна включить заголовочный файл "errno.h".
Большинство библиотечных функций возвращает специальное значение, чтобы указать, что они потерпели неудачу. Специальное значение типично 1, нулевой указатель, или константа типа EOF, которая определена для той цели. Но это значение возврата сообщает Вам только то, что ошибка произошла. Чтобы выяснять что это было, Вы должны рассмотреть код ошибки, сохраненный в переменной errno. Эта переменная объявлена в заголовочном файле "errno.h".
Переменная errno содержит номер ошибки системы. Вы можете изменять значение errno.
С тех пор как errno объявлена изменяемой, она может быть асинхронно изменена драйвером сигнала; см. раздел 21.4 [Определение драйверов]. Однако, правильно написанный драйвер сигнала сохраняет и восстанавливает значение errno, так что Вы вообще не должны волноваться относительно этой возможности, разве что при нааписании драйверов сигнала.
Начальное значение errno при запуске программы - нуль. Большинство библиотечных функций, когда они сталкиваются с некоторыми видами ошибок, помещают туда некоторое отличное от нуля значение. Эти ошибки условий перечислены для каждой функции. Если эти функции успешно выполняются они не изменяют errno; таким образом, значение errno после успешного обращения не обязательно нулевое, и Вы не должны использовать errno, чтобы определить, потерпело ли обращение неудачу. Соответствующий способ проверки зарегистрирован для каждой функции. Если обращение неудачно, Вы может исследовать errno.
Многие библиотечные функции могут устанавливать errno отличным от нуля в результате вызова других библиотечных функций, которые возможно и установили ошибку. Т. е. если функция возвращает ошибку, то любая библиотечная функция могла изменять errno.
Примечание относительно переносимоси: ANSI C определяет errno скорее как "модифицируемое именуемое выражение", чем как переменную, разрешая ему выполняться как макрокоманде. Например, его расширение может включать обращение к функции, подобно * _errno (). Фактически, это встроено систему GNU непосредственно. GNU библиотека, на не-GNU системах, делает то, что правильно для этой специфической системы.
Имеются несколько библиотечных функций, подобно sqrt и atan, которые в случае ошибки возвращают ожидаемое значение, устанавивая также errno. Для этих функций, если Вы хотите выяснить, произошла ли ошибка, рекомендуется обнулить errno перед вызовом функции, и затем проверить значение позже.
Все коды ошибки имеют символические имена; т. е. это макрокоманды, определенные в "errno.h". Имена начинаются с "E" и символа верхнего регистра или цифры; Вы должны рассмотривать имена такой формы, как зарезервированные имена. См. раздел 1.3.3 [Зарезервированные имена].
Значения кода ошибки - это различные положительные целые числа, с одним исключением: EWOULDBLOCK и EAGAIN - имеют одинаковый код. Так как значения отличны, Вы можете использовать их как метки в утверждении выбора; только не используйте, и EWOULDBLOCK и EAGAIN. Ваша программа не должна иметь никаких сомнений относительно специфических значений этих символических констант.
Значение errno не обязательно должно соответствовать одной из этих макрокоманд, так как некоторые библиотечные функции могут возвращать другие их собственные коды ошибки для других ситуаций. Единственные значения, которые будут важны для специфической библиотечной функции это списки кодов ошибок для этой функции.
На не-GNU системах, почти любой системный вызов может возвратить EFAULT, если как параметр задан недопустимый указатель. Так как это могло случиться только в результате ошибки в вашей программе, и так как этого не будет в системе GNU, мы сэкономили место не упоминая EFAULT в описаниях индивидуальных функций.
Макрокоманды кода ошибки определены в заголовочном файле "errno.h". Каждая из них преобразуется в константное целое значение. Некоторые из этих ошибок не могут произойти в системе GNU, но они могут происходить при использовании библиотеки GNU в других системах.
Не разрешенная операция; только владелец файла (или другого обьекта) или процессы со специальными привилегиями могут выполнять эту операцию.
Нет такого файла или каталога. Это - ошибка типа "файл не существует" для обычных файлов, которые вызваны в контекстах, где они, как ожидается, уже существуют.
Нет процесса соответствующего заданному.
Прерванное обращение к функции; асинхронный сигнал предотвратил завершение обращения. Когда это случается, Вы должны попробовать снова вызвать функцию.
Вы можете выбрать показ резюме функций после сигнала EINTR; см. раздел 21.5 [Прерванные Примитивы] .
Ошибка ввода-вывода, обычно используется для ошибок физического чтения или записи.
Нет такого устройства или адреса. Система попробовала использовать устройство, указанное файлом, который Вы определили, и не смогло найти это устройство. Это может означать, что файл устройства был установлен неправильно, или физическое устройство отсутствует или не правильно присоединено к компьютеру.
Список параметров слишком длинный; используется, когда параметры, переданные одной из функций (см. раздел 23.5 [Выполнение файла] ) занимают слишком много пространства памяти. Это условие никогда не возникает в системе GNU.
Недопустимый формат исполняемого файла. Это условие обнарживается запускаемыми функциями; см. раздел 23.5 [Выполнение файла].
Плохой описатель файла; например, ввод - вывод на описателе, который был закрыт или чтение из описателя, открытого только для записи (или наоборот).
Не имеется никаких порожденнных процессов. Эта ошибка случается при операциях, которые, как предполагается, управляют порожденнными процессами, когда не имеется ни каких процессов, для управления.
Тупик; распределение ресурсов системы оценено как ситуация тупика. Система не гарантирует, что она будет обращать внимание на все такие ситуации. Эта ошибка означает, что Вам повезло; система могла зависнуть. См. раздел 8.11 [Блокировки файла].
Нет доступной памяти. Система не может распределять виртуальную память, потому она полна.
Отклоненное право; права файла не позволяют предпринятую операцию.
Плохой адрес; был обнаружен недопустимый указатель.
Не специальный файл, был дан в ситуации, которая требует блок файов. Например, при попытке установить обычный файл как файловую систему в UNIX дает эту ошибку.
Ресурсы заняты; ресурс системы, который не может быть разделен уже используется. Например, если Вы пробуете удалить файл, который является корнем установленной в настоящее время файловой системы, Вы получаете эту ошибку.
Файл существует; существующий файл был определен в контексте, где имеет смысл определять только новый файл.
Была обнаружена попытка, сделать неподходящую компоновку файловой системы. Это случается не только, когда Вы используете связи (см. раздел 9.3 [Сложные связи]) но также, когда Вы переименовываете файл (см. раздел 9.6 [Переименование файлов]).
Функции, которая ожидает специфический тип устройства, был дан неправильный тип устройства.
Был определен файл, а не каталог, когда требуется каталог.
Указан каталог; попытка открыть каталог для записи дает эту ошибку.
Недопустимый параметр. Используется, чтобы указать различные виды проблем с указанием неправильного параметра для библиотечной функции.
Текущий процесс имеет слишком много открытых файлов и не может открыть больше. Двойные описатели приводят к этому ограничению.
Имеется слишком много различных открытых экземпляров файла во всей системе. Обратите внимание, что любое число связанных каналов считается только одним открытым экземпляром файла; см. раздел 8.5.1 [Связанные каналы]. Эта ошибка никогда не происходит в системе GNU.
Несоответствующая операция управления ввода - вывода, типа попытки устанавливать режимы терминала в обычном файле.
Попытка выполнить файл, который является в настоящее время открытым для записи, или записи в файл который в настоящее время выполняется. Это не является ошибкой в системе GNU; текст по мере необходимости копируется.
Файл слишком большой; размер файла больше чем позволено системой.
Нет места на устройстве; операция записи в файл потерпела неудачу, потому что диск полон.
Недопустимая операция установки.
Была сделана попытка изменить что - нибудь в файловой системе только для чтения.
Слишком много связей; число связей одиночного файла слишком велико. Переименование может вызывать эту ошибку, если переименовываемый файл уже имеет максимальное число связей (см. раздел 9.6 [Переименование файлов]).
Разрушенный канал; не имеется процесса читающего с другого конца канала. Каждая библиотечная функция, которая возвращает этот код ошибки также генерирует сигнал SIGPIPE; если этот сигнал не обработан или не блокирован, то он завершает программу . Таким образом, ваша программа фактически не будет никогда видеть EPIPE, если она не обработала или не блокировала SIGPIPE.
Ошибка области; использование математических функций, когда значение параметра не относится к области над которой функция определена.
Ошибка диапазона; использование математических функций, когда значение результата не представимо из-за переполнения.
Ресурс временно недоступен; обращение может работать, если Вы пробуете позже.
Операция, которая бы была блокировала предпринята на объекте, который имеет выбранный режим не-блокирования.
Примечание относительно переносимости: В 4.4BSD и GNU, EWOULDBLOCK и EAGAIN - совпадают. Более ранние версии BSD (см. раздел 1.2.3 [Berkeley UNIX]) имеют два различных кода, и используют EWOULDBLOCK, чтобы указать операцию ввода-вывода, которая блокировала бы объект с набором режимов неблокирования, а EAGAIN для других видов ошибок.
Операция, которая не может завершаться немедленно, была инициализирована в объекте, который имеет выбранный режим неблокирования. Некоторые функции, которые должны всегда блокировать (типа, connect ; см., раздел 11.8.1 [Соединение] ) никогда не возвращает EWOULDBLOCK. Взамен, они возвращают EINPROGRESS, чтобы указать, что операция начата и займет некоторое время. Попытайтесь управлять объектом прежде, чем обращение завершится возвратив EALREADY.
Операция уже выполняется в объекте, который имеет выбранный режим неблокирования.
Был определен файл,а не гнездо, когда требуется гнездо.
Нет был обеспечен адрес адресата для операции гнезда.
Размер сообщения, посланного на гнездо был больше чем обеспечиваемый максимальный размер.
Тип гнезда не поддерживает запрашиваемый протокол связи.
Вы определили опцию гнезда, которая не имеет смысла для специфического протокола, используемого гнездом. См. раздел 11.11 [Опции гнезда].
Область гнезда не поддерживает запрашиваемый протокол связи (возможно, потому что запрашиваемый протокол полностью недопустим.) См. раздел 11.7.1 [Создание гнезда].
Тип гнезда не установлен.
Операция, которую Вы запросили, не обеспечивается. Некоторые функции гнезда не имеют смысла для всех типов гнезд, а другие не имеют права выполнения для всех протоколов связи.
Семейство протоколов связи гнезда, которое Вы запросили, не обеспечивается.
Семейство адресов, заданное для гнезда несогласованно с протоколом, используемым на гнезде. См. Главу 11 [Гнезда].
Запрашиваемый адрес гнезда - уже используется. См. раздел 11.3 [Адреса гнезда].
Запрашиваемый адрес гнезда не доступен; например, Вы попробовали дать гнезду имя, которое не соответствует местному главному имени. См. раздел 11.3 [Адрес Гнезда].
Операция с гнездом потерпела неудачу, потому что нет сети.
Операция гнезда потерпела неудачу, потому что подсеть, содержащая главную ЭВМ была недоступна.
Сетевое соединение было сброшено, потому что отдаленная главная ЭВМ умерла.
Сетевое соединение было прервано локально.
Сетевое соединение было закрыто по внешним причинам контроля над местной главной ЭВМ, например из-за неисправимого нарушения протокола.
Буфера ядра для операций ввода - вывода занят весь.
Вы пытаетесь соединить гнездо, которое уже соединено. См. раздел 11.8.1 [Соединение].
Гнездо не соединено с чем - нибудь. Вы получаете эту ошибку, когда Вы пробуете передавать данные на гнездо, без первого определения адресата для данных.
Гнездо уже было закрыто.
Операция гнезда с заданной блокировкой по времени не получила никакого ответа в течение периода блокировки по времени.
Отдаленная главная ЭВМ отказала в сетевом соединении (обычно из-за того, что не запущено запрашиваемое обслуживание).
При поиске имени файла столкнулись со слишком многими уровнями символических связей. Часто это указывает на цикл символических связей.
Имя файла слишком длинное (больше чем PATH_MAX; см. раздел 27.6 [Ограничения для файлов]) или главное имя слишком длинное (в gethostname или sethostname; см. раздел 26.1 [Главная идентификация]).
Отдаленная главная ЭВМ для запрашиваемого сетевого соединения не реагирует.
Отдаленная главная ЭВМ для запрашиваемого сетевого соединения не доступна.
Каталог, не пустой, а ожидался пустой каталог. Обычно эта ошибка происходит, когда Вы пробуете удалять каталог.
Файловая система спутана, потому что имеется слишком много пользователей.
Пользовательское дисковое пространство превышено.
Просроченная NFS программа обработки файла. Это указывает на внутренний беспорядок в NFS системе, который появляется из-за перестановок файловой системы на главной ЭВМ станции. Восстановление этого условия обычно требует переустановки файловой системы NFS на местной главной ЭВМ.
Была сделана попытка NFS-подсоединения удаленной файловой системой с именем файла, которое уже определяет установленный файл NFS. (Эта ошибка воникает на некоторых операционных системах, но мы думаем что это будет работать правильно на системе GNU, делающей этот код ошибки невозможным.)
Нет доступной блокировки. Это используется средствами закрытия файла; см. раздел 8.11 [Блокировки файла]. Эта ошибка никогда не происходит в системе GNU.
Функция не выполнена. Некоторые функции имеют команды или определяющие их опции, которые не могут обеспечиваться во всех реализациях, и это - ошибка, которую Вы получаете, если Вы запрашиваете то, что не обеспечивается.
В системе GNU, станции, обеспечивающие протокол терминала возвращают эту ошибку для некоторых операций, когда вызывающий оператор не входит в группу приоритетного процесса терминала. Пользователи обычно не видят эту ошибку, потому что функции типа чтения и записи транслируют ее в SIGTTIN или SIGTTOU сигнал. См. Главу 24 [Управление заданиями], для уточнения информации относительно групп процессов и этих сигналов.
Опытный пользователь будет знать, что неправильно.
Что Вы делаете?!!!
Идите домой и выпейте стакан теплого молока.
Библиотека имеет функции и переменные, разработанные, чтобы облегчить для вашей программы вывод информативных сообщений об ошибках в обычном формате. Функции strerror и perror дают Вам стандартное сообщение об ошибках для данного кода ошибки; переменная program_invocation_short_name дает Вам удобный доступ к имени программы, которая столкнулась с ошибкой.
сhar * strerror ( int errnum) (функция)
Значение errnum обычно исходит из переменной errno.
Вы не должны изменять строку, возвращаемую strerror. Также, если Вы делаете последующие обращения к strerror, новая строка могла быть записана поверх старой. (Но гарантируется, что никакая библиотечная функция не вызовет strerror за вашей спиной.) Функция strerror объявлена в "string.h".
void perror (const char * message) (функция)
Если Вы вызываете perror с сообщением, которое является или нулевым указателем или пустой строкой, perror печатает сообщение об ошибках, соответствуя errno, добавляя конечный символ перевода строки.
Если Вы обеспечиваете не-нулевой параметр сообщения, то perror начинает вывод с этой строки. Она добавляет двоеточие и пробел, чтобы отделить сообщение от строки ошибки, соответствующей errno.
Функция perror объявлена в "stdio.h".
strerror и perror производят точно то же самое сообщение для любого данного кода ошибки; точный текст изменяется от системы до системы. На системе GNU, сообщения довольно коротки; не имеются никаких многострочных сообщений или вложенных символов перевода строки. Каждое сообщение об ошибках начинается заголовочной буквой и не включает ни какой пунктуации завершения.
Примечание относительно совместимости: функция strerror - новая особенность ANSI C, многие более старые C системы не поддерживают эту функцию.
Множество программ, которые не читают ввод с терминала, разработаны, чтобы выйти, если любой системный вызов терпит неудачу. В соответствии c соглашением, сообщение об ошибках из такой программы должно начаться с имени программы. Вы можете найти это имя в переменной program_invocation_short_name; полное имя файла сохранено в переменной program_invocation_name:
сhar * program_invocation_name (переменная)
сhar * program_invocation_short_name (переменная)
Библиотечные код инициализации устанавливает обе из этих переменных перед вызовом main.
Примечание относительно переносимости: Эти две переменные расширения GNU. Если Вы хотите, чтобы ваша программа работала с библиотеками, не относящимися к GNU, Вы должны сохранить значение argv [0] в main (основной программе), и удалить имена каталогов самостоятельно. Мы добавили эти расширения, чтобы сделать возможной написание замкнутых сообщений об ошибках подпрограммы, которые не требуют никакого явного сотрудничества с основной программой.
Имеется пример, показывающий, как обработать отказ открывать файл. Функция open_ sesame пробует открывать указанный файл для чтения и возвращает поток. Библиотечная функция fopen возвращает нулевой указатель, если она не может открыть файл по некоторым причинам. В той ситуации, open_sesame создает соответствующее сообщение об ошибках, используя функцию strerror, и завершает программу. Если мы хотим сделать другие вызовы из библиотек перед передачей кода ошибки к strerror, мы должны сохранить его в местной переменной, потому что те другие библиотечные функции могут записывать поверх errno.
#include <errno.h>
#include <stdio.h>
#include < stdlib.h >
#include <string.h>
FILE * open_sesame (char *name)
{
FILE *stream;
errno = 0;
stream = fopen (name, "r");
if (stream == NULL)
{
fprintf (stderr, "%s: Couldn't open file %s; %s\n",
program_invocation_short_name, name, strerror (errno));
exit (EXIT_FAILURE);
}
else return stream;
}
Система GNU обеспечивает несколько методов для распределения пространства памяти при явном управлении программы. Они различны по общности и по эффективности.
Динамическое распределение памяти - методика, в которой программы определяют, где сохранить некоторую информацию. Вы нуждаетесь в динамическом распределении, когда число блоков памяти, в которых Вы нуждаетесь, или то, как долго Вы продолжаете нуждаться в них, зависит от данных, с которыми Вы продолжаете работать.
Например, Вы можете нуждаться в блоке, чтобы сохранить строку прочитанную из входного файла; так как не имеется никаких ограничений, как долго нужно будет хранить строку, Вы должны динамически распределить память и динамически ее увеличивать, поскольку Вы читаете большее количество строк.
Или, Вам может понадобиться блок для каждой записи или каждого определения во входных сведениях; так как Вы не можете знать заранее, сколько их будет, Вы должны определять новый блок для каждой записи или определения, поскольку Вы их читаете.
Когда Вы используете динамическое распределение, распределение блока памяти представляет собой действие, которое программа запрашивает явно. Когда Вы хотите зарезервировать место, Вы вызываете функцию или макрокоманду и определяете размер аргументом. Если Вы хотите освободить место, Вы вызываете другую функцию или макрокоманду. Вы можете делать это всякий раз, когда Вы хотите, и так часто, как Вы хотите.
Язык С поддерживает два вида распределения памяти через переменные в программах C:
Динамическое распределение не обеспечивается C переменными; не имеется никакого класса памяти "dynamic", и не может быть переменной C, чье значение сохранено в динамически размещенном месте. Единственный способ обратиться к динамически размещенному месту - через указатель. Т.к. это менее удобно, и фактический процесс динамического распределения требует большего количества компьютерного времени, программисты использует динамическое распределение только когда ни статическое ни автоматическое распределение применить невозможно.
Например, если Вы хотите зарезервировать динамически некоторое место, чтобы разместить struct foobar, Вы не можете объявлять переменную типа struct foobar, чье содержание - динамически размещенное место. Но Вы можете объявить переменную struct foobar * типа указатель и назначить ей адрес. Тогда Вы можете использовать операторы "*" и "->" для этой переменной- указателя, чтобы обратиться по адресу:
{
struct foobar *ptr= (struct foobar *) malloc (sizeof (struct foobar));
ptr->name = x;
ptr->next = current_foobar;
current_foobar = ptr;
}
Наиболее общее динамическое средство распределения - malloc. Оно разрешает Вам зарезервировать блоки памяти любого размера в любое время, увеличивать или уменьшать их, и освободждать блоки индивидуально в любое время (или не освобождать) .
Чтобы зарезервировать блок памяти, вызовите malloc. Прототип для этой функции находится в "stdlib.h".
void * malloc (size _t size) (функция)
Содержание блока неопределено; Вы должны инициализировать его непосредственно (или использовать calloc; см. раздел 3.3.5 [Распределение очищенного места] ). Обычно Вы приводите значение указателя к виду объекта, который Вы хотите сохранять в блоке. Здесь мы показываем такой пример, и инициализации место нулями, используя библиотечную функцию memset (см. раздел 5.4 [Копирование и конкатенация]):
struct foo *ptr;
. . .
ptr = (struct foo *) malloc (sizeof (struct foo));
if (ptr == 0) abort ();
memset (ptr, 0, sizeof (struct foo));
Не забудьте, что при распределении пространства для строки, аргумент malloc должен быть один плюс длина строки. Это - потому что строка завершена символом \0, который не учтен в "длине" строки, но нуждается в месте. Например:
char *ptr;
. . .
ptr = (char *) malloc (length + 1);
Если место не доступно, malloc возвращает нулевой указатель. Вы должны проверить значение каждого обращения к malloc. Полезно написать подпрограмму, которая вызывает malloc и сообщает ошибку, если значение нулевой указатель, и возвращает результат только если значение отлично от нуля. Эта функция традиционно называется xmalloc:
void * xmalloc (size_t size)
{
register void *value = malloc (size);
if (value == 0) fatal ("virtual memory exhausted");
return value;
}
char * savestring (const char *ptr, size_t len)
{
register char *value = (char *) xmalloc (len + 1);
memcpy (value, ptr, len);
value[len] = '\0';
return value;
}
Обратите внимание, что память, размещенная после конца блока, вероятно будет в использовании для чего - нибудь еще; возможно для блока, уже размещенный другим обращением к malloc. Если Вы пытаетесь обрабатывать блок как дольше чем Вы установили, Вы можете разрушить данные, что malloc использует, чтобы следить за блоками, или Вы можете разрушить содержимое другого блока. Если Вы уже зарезервировали блок и обнаруживаете, что Вам нужен больший, используйте перераспределение (см. раздел 3.3.4 [Изменение размеров блока]).
Когда Вы больше не нуждаетесь в блоке, который Вы создали malloc, используйте функцию free чтобы сделать блок доступным, для следующего резервировния. Прототип для этой функции находится в "stdlib.h".
void free (void * ptr) (функция)
void cfree (void * ptr) (функция)
Освобождение блока изменяет содержание блока. Не ищите какие-либо данные (типа указателя на следующий блок в цепочке блоков) в блоке после его освобождения. Копируйте все необхоимое во вне блока перед его освобождением! Вот пример соответствующего способа освободить все блоки в цепочке, и строки на которые они указывают:
struct chain {struct chain *next; char *name;}
void free_chain (struct chain *chain)
{
while (chain != 0)
{
struct chain *next = chain->next;
free (chain->name);
free (chain);
chain = next;
}
}
В конце программы, не имеется никаких указателей на освобожденые блоки, потому что все место программы было отдано обратно системе, когда процесс завершвлся.
Часто Вы не уверены, насколько большой блок Вам будетнужен в конечном счете. Например, блок может быть буфером, что Вы используете, чтобы содержать строку читаемую из файла; неважно какой длины Вы делаете буфер первоначально, Вы можете сталкнуться со строкой, которая будет длиннее.
Вы можете делать блок длиннее, вызывая realloc. Эта функция объявлена в "stdlib.h".
void * realloc (void * ptr, size _t newsize) (функция)
Если место после конеца блока используется, realloc скопизует блок по новому адресу, где доступно большее количество свободного пространства. Значение realloc - новый адрес блока. Если блок должен передвигаться, realloc, копирует старое содержимое.
Если Вы передаете пустой указатель для ptr, realloc, ведет себя точно так же как "malloc (newsize)". Это может быть удобно, но остерегайтесь более старых реализаций (до ANSI C) которые не имеют права поддерживать это поведение, и будут вероятно что-то разрушать , когда realloc получит пустой указатель.
Подобно malloc, realloc может возвращать пустой указатель, если никакое пространство памяти не доступно, чтобы увеличить блок. Когда это случается, первоначальный блок остается нетронутым; он не изменяется и не перемещается.
В большинстве случаев это не имеет значения, что случается с первоначальным блоком, когда realloc терпит неудачу, потому что прикладная программа не может продолжаться, когда не хватает памяти, и единственное что, нужно сделать - это выдать сообщение о фатальной ошибке. Часто бывает удобно написать и использовать подпрограмму, традиционно называемую xrealloc, которая заботится о сообщениях об ошибках, как xmalloc делает для malloc:
void * xrealloc (void *ptr, size_t size)
{
register void *value = realloc (ptr, size);
if (value == 0) fatal ("Virtual memory exhausted");
return value;
}
Если новый размер, который Вы определяете - такой же как старый, realloc, не изменит ничего и возвратит тот же самый адрес, который Вы дали.
Функция calloc резервирует память и обнуляет ее. Она объявлена в "stdlib.h".
void * calloc (size_t count, size _t eltsize) (функция)
Вы можете определять calloc следующим образом:
void * calloc (size_t count, size_t eltsize)
{
size_t size = count * eltsize;
void *value = malloc (size);
if (value != 0) memset (value, 0, size);
return value;
}
Чтобы лучше использовать malloc, нужно знать, что GNU версия malloc всегда назначает наименьший объем памяти в блоках, чьи размеры являются степенями двойки. Она хранит раздельные пулы для каждой степени двойки. И каждый занимает столько места сколько страница. Следовательно, если у Вас есть свободный выбор размера маленького блока, чтобы сделать malloc более эффективным, делайте его степенью двойки.
Если страница разбита для определенного размеа блока, она не может многократно использоваться для другого размера, если все блоки этого размера не освобождены. В многих программах маловероятно, что это случается. Таким образом, Вы можете иногда делать программы использующие память более эффективно, используя блоки того же самого размера для многих различных целей.
Когда Вы запрашиваете о блоках памяти рамера страницы или больших, malloc использует различную стратегию; она округляет сверху размер до нескольких размеров странцы, и может обьединять и разбивать блоки как необходимо.
Причина для двух cтратегий то, что важно зарезервировать и освободить маленькие блоки так быстро как возможно, но для большого блока быстродействие менее важно, так как программа обычно тратит больше времени используя его. Больших блоков обычно меньше. Следовательно, для больших блоков, имеет смысл использовать метод, который занимает большее количество времени, чтобы минимизировать потраченное впустую место.
Адрес блока, возвращенного malloc или realloc в системе GNU всегда делится на восемь. Если Вы нуждаетесь в блоке, чей адрес делится на более высокой степень двойки чем этот, используйте memalign или valloc. Эти функции объявлены в "stdlib.h".
С библиотекой GNU, Вы можете использовать free, чтобы освободить блоки которые возвращают memalign и valloc. Это не работает в BSD, т. к. BSD не обеспечивает ни какого способа освободить такие блоки.
void * memalign (size _t size, size _t boundary) (функция)
void * valloc (size _t size) (функция)
void * valloc (size_t size)
{
return memalign (size, getpagesize ());
}
Вы можете указать, чтобы malloc проверила непротиворечивость динамической памяти, используя функцию mcheck. Эта функция - расширение GNU, объявленное в "malloc.h".
int mcheck (void (* abortfn) (void)) (функция)
аbortfn аргумент - это функция, которая вызвается, когда несогласованность найдена. Если Вы обеспечиваете пустой указатель, используется функция аварийного прекращения работы.
Слишком поздно начинать проверку, если Вы уже зарезервировали что- нибудь с помощью malloc. Так как mcheck в этом случае ничего не делает. Функция возвращает -1, если Вы вызываете ее слишком поздно, и 0 иначе (в случае успеха).
Самый простой способ вызывать mcheck вовремя состоит в том, чтобы использовать опцию "-lmcheck" когда Вы компонуете вашу программу; то Вы вообще не должны изменять вашу исходную программу.
GNU C библиотека позволяет Вам изменять поведение malloc, realloc, и free, определяя соответствующие функции ловушки. Вы можете использовать эти ловушки, чтобы отладить программы, которые используют динамическое резервирование памяти.
Переменные-ловушки объявлены в "malloc.h".
Значение этой переменной - указатель на функцию, которe realloc использует всякий раз, когда вызывается. Вы должны определить эту функцию, как:
void * function (void * ptr, size _t size)
Значение этой переменной - указатель на функцию, которую free использует всякий раз, когда вызывается. Вы должны определить эту функцию, как:
void function (void * ptr)
static void *(*old_malloc_hook) (size_t);
static void * my_malloc_hook (size_t size)
{
void *result; __malloc_hook = old_malloc_hook;
result = malloc (size);
__malloc_hook = my_malloc_hook;
printf ("malloc (%u) returns %p\n", (unsigned int) size, result);
return result;
}
main ()
{
...
old_malloc_hook = __malloc_hook;
__malloc_hook = my_malloc_hook;
...
}
Вы можете получить информацию относительно динамического резервирования памяти, вызывая функцию mstats. Эта функция и связанный тип данных объявлены в "malloc.h"; они являются расширением GNU.
struct mstats (тип данных)
size_t bytes_total
size_t chunks_used
size_t bytes_used
size_t chunks_free
size_t bytes_free
struct mstats mstats (void) (функция)
Это обзор функций, которые имеют отношение к malloc:
void * malloc (size _t size)
void free (void *addr)
void * realloc (void * addr, size _t size)
void * calloc (size _t count, size _t eltsize)
void * valloc (size _t size)
void * memalign (size _t size, size _t boundary)
int mcheck (void (* abortfn) (void))
void * (* __ malloc_hook) (size _t size)
void * (* __ realloc _hook) (void * ptr, size _t size)
void (* __ free _hook) (void * ptr)
struct mstats mstats (void)
obstack - пул памяти, содержащей стек объектов. Вы можете создавать любое число различных obstacks, и зарезервировать объекты в заданном obstacks. Внутри каждого obstack, последний размещенный объект должен всегда быть первым освобожденным, но различные obstacks независят от друг друга.
Кроме этого одного ограничения на порядок освобождения, obstacks полностью свободен: obstack может содержать любое число объектов любого размера. Они выполнены как макрокоманды, так что резервирование обычно очень быстро, так как объекты обычно маленькие. И единственные дополнительные непроизводительные затраты на объект необходимы, чтобы начать каждый объект с подходящей границы.
Утилиты для управления obstacks объявлены в заголовочном файле "obstack.h".
struct obstack (тип данных)
Вы можете объявлять переменные типа struct obstack и использовать их как obstacks, или Вы можете зарезервировать obstacks динамически подобно любому другому виду объекта. Динамическое резервирование obstacks разрешает вашей программе иметь переменное число различных стеков. (Вы можете даже зарезервировать структуру obstack в другом obstack, но это редко требуется.)
Все функции, которые работают с obstacks, требуют, чтобы Вы определили, какой obstack использовать. Вы делаете это указателем типа struct obstack *. Далее, мы часто будем говорить "obstack" когда, строго говоря, имеем в виду такой указатель.
Объекты в obstack упакованы в большие блоки называемые кусками. Структура struct obstack указывает на цепочку используемых в настоящее время кусков.
Библиотека obstack получает новый кусок всякий раз, когда Вы резервируете объект, которому не удовлетворяет предыдущий кусок. Так как библиотека obstack управляет кусками автоматически, Вы не должны уделять им много внимания, но Вы должны обеспечить функцию, которую библиотека obstack должна использовать, чтобы получить кусок. Обычно Вы обеспечиваете функцию, которая использует malloc непосредственно или косвенно. Вы должны также обеспечить функцию освобождения куска. Эти вопросы описаны в следующем разделе.
В каждый исходный файл, в котором Вы планируете использовать функции obstack, следует включить заголовочный файл "obstack.h":
#include <obstack.h>
Обычно они определены, чтобы использовать malloc через посредника xmalloc (см. раздел 3.3 [Беспрепятственное Резервирование]). Это выполнено следующей парой макроопределений:
#define obstack_chunk_alloc xmalloc*
#define obstack_chunk_free free
Во время выполнения, прежде, чем программа может использовать struct obstack object как obstack, она должна инициализировать obstack, вызывая obstack_init.
void obstack_init (struct obstack * obstack_ptr) (функция)
Имеются два примера того, как зарезервировать пространство для obstack и инициализировать его. Первый, obstack, который является статической переменной:
static struct obstack myobstack;
...
оbstack_init (&myobstack);
struct obstack * myobstack_ptr= (struct obstack *) xmalloc (sizeof(struct obstack));
obstack_init (myobstack_ptr);
Наиболее прямой способ зарезервировать объект в obstack - через obstack_alloc, которая вызывается почти как malloc.
void * obstack_alloc (struct obstack * obstack_ptr, size _t size) (функция)
Например функция, которая резервирует копию строки str в определенном obstack, который находится в переменной string_obstack:
struct obstack string_obstack;
char * copystring (char *string)
{
char *s = (char *) obstack_alloc (&string_obstack, strlen (string) + 1);
memcpy (s, string, strlen (string));
return s;
}
void * obstack_copy (struct obstack * obstack_ptr, void *address, size_t size) (функция)
vоid * obstack_copy0 (struct obstack * obstack_ptr, void *address, size _t size) (функция)
Функция obstack_copy удобна для копирования последовательности символов в obstack как законченной пустым символом строки. Пример использования:
char * obstack_savestring (char * addr, size _t size)
{
return obstack_copy (myobstack, addr, size);
}
Для освобждения объекта, размещенный в obstack, используйте функцию obstack_free. Так как obstack - стек объектов, освобождение одного объекта автоматически освобождает все другие объекты, зарезервированные позже в том же самом obstack.
void obstack_free (struct obstack * obstack_ptr, void * object) (функция)
Обратите внимание, что, если object является пустым указателем, то результат - неинициализированный obstack. Для освобождения всей памяти в obstack, с возможным его использованием для дальнейшего резервирования, вызовите obstack_free с адресом первого объекта, размещенного в obstack:
obstack_free (obstack_ptr, first_object_allocated_ptr);
Интерфейсы для использования obstacks могут быть определены или как функции или как макрокоманды, в зависимости от транслятора. obstack средство работает со всеми C трансляторами, включая, и ANSI C и традиционный C, но имеются предосторожности, которые Вы должны соблюдать, если Вы планируете использовать трансляторы отличные от GNU C.
Если Вы используете традиционный не ANSI C транслятор, все obstack "функции" фактически определены только как макрокоманды. Вы можете вызывать эти макрокоманды подобно функциям, но Вы не можете использовать их любым другим способом (например, Вы не можете брать их адрес).
Вызов макрокоманд требует некоторых предосторожностей: а именно, первый операнд (указатель на obstack) не имеет права содержать никаких побочных эффектов, потому что он может быть вычислен больше чем один раз. Например, если Вы напишете: obstack_alloc (get_obstack (), 4), Вы увидите, что get_obstack может называться несколько раз. Если Вы используете * obstack_list_ptr ++ как аргумент-указатель obstack, Вы получите очень странные результаты, так как приращение может происходить несколько раз.
В ANSI C, каждая функция имеет, и макроопределение и определение функции. Определение функции используется, если Вы берете адрес функции без того, чтобы вызвать ее. Обычное обращение использует макроопределение по умолчанию, но Вы можете запрашивать определение функции, написав имя функции в круглых скобках, как показано здесь:
char * x; void * (* funcp) (); /* Используем макрокоманду. */
x = (char *) obstack_alloc (obptr, size); /* Вызываем функцию. */
x = (char *) (obstack_alloc) (obptr, size); /* Берем адрес функции. */
funcp = obstack_alloc;
Предупреждение: Когда Вы используете макрокоманды, Вы должны соблюдать предосторожности избавившись от побочных эффектов в первом операнде, даже в ANSI C.
Если Вы используете транслятор GNU C, эта предосторожность, необязательна, потому что различные расширения языка в GNU C разрешают определять макрокоманды, чтобы вычислять каждый аргумент только один раз.
Т.к. память в кусках obstack используется последовательно, возможно создать объект шаг за шагом, добавляя один или больше байт сразу к концу объекта. При таком способе, Вы не должны знать, сколько данных у Вас будет включено в объект до этого. Мы называем это методикой возрастастающих объектов. В этом разделе описаны специальные функции для добавления данных к возрастастающему объекту.
Вы не должны делать что-нибудь особенное, когда Вы начинаете наращивать объект. Использование одной из функций, чтобы добавить данные к объекту автоматически начинает его. Однако, необходимо явно указать, когда объект закончен. Это выполняется функцией obstack_finish.
Действительный адрес объекта, созданного таким образом не известен, пока объект не закончен. До тех пор, всегда остается возможность, что Вы добавите так много данных, что объект придется скопировать в новый кусок.
Поскольку obstack используется для возрастастающего объекта, Вы не можете использовать obstack для обычного резервирования другого объекта. Если, Вы попробуете это сделать, то место, уже добавленное к возрастастающему объекту, станет частью другого объекта.
void obstack_blank (struct obstack * obstack_ptr, size _t size) (функция)
void obstack_grow (struct obstack * obstack_ptr, void *data , size_t size) (функция)
void obstack_grow0 (struct obstack * obstack_ptr, void *data, size_t size) (функция)
void obstack_1grow (struct obstack * obstack_ptr, char c) (функция)
void * obstack_finish (struct obstack * obstack_ptr) (функция)
Если Вы закончили объект, obstack доступен для обычного резервирования или для увеличения другого объекта.
Когда Вы формируете объект, Вы будете вероятно должны знать, позже сколько места занял. Вы не должны следить за этим, потому что Вы можете выяснять длину из obstack перед самым окончанием объекта функцией obstack_object_size, объявленный следующим образом:
size _t obstack_object_size (struct obstack * obstack_ptr) (функция)
Если Вы начали увеличивать объект и желаете отменить это, Вы должны закончить его и тогда освободить его, примерно так:
obstack_free (obstack_ptr, obstack_finish (obstack_ptr));
Вы можете использовать obstack_blank с отрицательным аргументом size, чтобы делать текущий объект меньше. Только не пробуйте сокращать его до меньше нуля, не имеется никаких сведенний, что случиться, если Вы сделаете это.
Обычные функции для возрастастающих объектов делают непроизводительные затраты для проверки, имеется ли участок памяти для нового роста в текущем куске. Если Вы часто создаете объекты в с маленькими шагами роста, эти непроизводительные затраты, могут быть значительны.
Вы можете уменьшать непроизводительные затраты, используя специальный "быстрый рост", т. е. функции, которые выращивают объект без проверки. Чтобы иметь здоровую программу, Вы должны делать проверку самостоятельно. Если Вы делаете это самым простым способом каждый раз. когда Вы собираетесь, добавлять данные к объекту, Вы ничего не приобретете, потому что это и делают обычные функции возрастания. Но если Вы можете проверить менее часто, или проверять более эффективно, то Вы сделаете программу быстрее.
Функция obstack_room возвращает количество памяти, доступной в текущем куске. Она объявлена следующим образом:
size _t obstack_room (struct obstack * obstack_ptr) (функция)
Если Вы знаете, что имеется участок памяти, Вы можете использовать эти быстрые функции роста для добавления данных к возрастастающему объекту:
void obstack_1grow_fast (struct obstack * obstack_ptr, char c) (функция)
void obstack_blank_fast (struct obstack * obstack_ptr, size _t size) (функция)
Если Вы проверяете место, используя obstack_room и нет достаточного участка памяти, для того, что Вы хотите добавлять, то быстрые функции роста не безопасны. В этом случае, просто используйте соответствующую обычную функцию роста. Если она будет копировать объект в новый кусок; то будет иметься больше доступной памяти.
Так, каждый раз когда Вы используете обычную функцию роста, проверяйте есть ли достаточного места, используя obstack_room. Как только объект скопирован в новый кусок, будет снова иметься много места, так что программа будет начинать использовать быстрые функции роста.
Вот пример:
void add_string (struct obstack * obstack, char * ptr, size _t len)
{
while (len > 0)
{
if (obstack_room (obstack) > len)
{ /* Мы имеем достаточный участок памяти: добавляйте все
быстро. */
while (len - > 0) obstack_1grow_fast (obstack, * ptr ++);
}
else
{
/* Нет достаточного участка памяти. Добавьте один символ, он может
быть скопирован в новый кусок для создания места. */
obstack_1grow (obstack, * ptr ++); len -;
}
}
}
Имеются функции, которые обеспечивают информацию относительно текущего состояния резервирования в obstack. Вы можете использовать их, чтобы узнать относительно объекта при все еще возрастании это.
void * obstack_base (struct obstack * obstack_ptr) (функция)
Если никакой объект в данный момент не возрастастает, это значение показывает, где будет начинаться следующий объект, который Вы зарезервируете.
void * obstack_next_free (struct obstack * obstack_ptr) (функция)
size _t obstack_object_size (struct obstack * obstack_ptr) (функция)
Каждый obstack имеет границу выравнивания; каждый объект, размещенный в obstack автоматически начинается на адресе, который делится на заданную границу (выравнивание). По умолчанию, эта граница 4 байта.
Чтобы обращаться к границе выравнивания obstack, используйте макрокоманду obstack_alignment_mask, чей функциональлный прототип
int obstack_alignment_mask (struct obstack * obstack_ptr) (макрос)
Расширение макрокоманды obstack_alignment_mask - именующее выражение, так что Вы можете изменять маску назначением. Например, это утверждение:
obstack_alignment_mask (obstack_ptr) = 0;
Обратите внимание, что изменение в маске выравнивания не действует до окончания или размещения следующего объекта в obstack. Если Вы не увеличиваете объект, Вы может заставить новую маску выравнивания воздействовать немедленно, вызывая obstack_finish. Она заканчит объект нулевой длины и то сделает соответствующее выравнивание для следующего объекта.
obstacks работает, резервируя пространство для себя в больших кусках, и разбивает место снаружи на куски, чтобы удовлетворить ваши запросы. Куски - обычно длиной 4096 байтов, если Вы не определите другой размер куска. Размер куска включает 8 байтов непроизводительных затрат, которые фактически не используются для сохранения объектов. Независимо от заданного размера, длинные объекты будут размещены в более длинные куски, когда необходимо.
obstack библиотека зервирует куски, вызывая функцию obstack_chunk_alloc, которую Вы должны определить. Когда кусок больше не нужен, если Вы освободили в нем все объекты, obstack библиотека освобождает кусок, вызывая obstack_chunk_free, которыую Вы должны также определить.
Эти две функции должны быть определены (как макрокоманды) или объявляться (как функции) в каждом исходном файле, который использует obstack_init (см. раздел 3.4.1 [Создание obstacks]). Наиболее часто они определены как макрокоманды подобно:
#define obstack_chunk_alloc xmalloc
#define obstack_chunk_free free
Функция, которая фактически осуществляет obstack_chunk_alloc, не может возвратить "отказ" в любом режиме, потому что obstack библиотека не подготовлена, чтобы обработать отказ. Следовательно, malloc непосредственно не подходит. Если функция не может получить место, она должна также завершить процесс (см. раздел 22.3 [Прерывание программ] или делать нелокальный выход, используя longjmp (см. Главу 20 [Нелокальные выходы] ).
Если Вы зарезервируете куски с malloc, размер куска, должен быть степенью 2. Заданный по умолчанию размер куска - 4096, был выбран, достаточно большим чобы удовлетворить много типичных запросов на obstack однако достаточно коротким, чтобы не тратить впустую слишком много памяти.
size _t obstack_chunk_size (struct obstack * obstack_ptr) (макрос)
Так как эта макрокоманда расширяется до именующего выражения, Вы можете определить новый размер куска, назначая новое значение. Ее выполнение не подействует на куски, уже размещенные, но изменит размер кусков, размещенных в том конкретном obstack в будущем., вряд ли, будет полезно сделать размер куска меньше, но создание большего могло бы увеличивать эффективность, если Вы зарезервируете много объектов, чьи размеры являются сравнимыми с размером куска. Вот как это можно сделать:
if (obstack_chunk_size (obstack_ptr) < new_chunk_size)
obstack_chunk_size (obstack_ptr) = new_chunk_size;
Это обзор всех функций, связанных с obstack. Каждая берет в качестве первого аргумента адрес obstack (struct obstack *).
void obstack_init (struct obstack * obstack'ptr)
void * obstack_alloc (struct obstack * obstack'ptr, size_t size)
void * obstack_copy (struct obstack * obstack'ptr, void *address, size_t size)
void * obstack_copy0 (struct obstack * obstack'ptr, void *address, size_t size)
void obstack_free (struct obstack * obstack'ptr, void * object)
void obstack_blank (struct obstack * obstack'ptr, size_t size)
void obstack_grow (struct obstack * obstack'ptr, void * address,
size _t size)
void obstack_grow0 (struct obstack * obstack'ptr, void * address,
size _t size)
void obstack_1grow (struct obstack * obstack'ptr, char data'char)
void * obstack_finish (struct obstack * obstack'ptr)
size _t obstack_object_size (struct obstack * obstack'ptr)
void obstack_blank_fast (struct obstack * obstack'ptr, size _t size)
vid obstack_1grow_fast (struct obstack * obstack'tr, char
data'char)
size _t obstack_room (struct obstack * obstack'ptr)
int obstack_alignment_mask (struct obstack * obstack'ptr)
size _t obstack_chunk_size (struct obstack * obstack'ptr)
void * obstack_base (struct obstack * obstack'ptr)
void * obstack_next_free (struct obstack * obstack'ptr)
Функция alloca поддерживает вид полудинамического резервирования, в котором блоки размещены динамически, но освобождаются автоматически.
Распределение блока alloca - явное действие; Вы можете зарезервировать так много блоков, как Вы желаете, и вычислять размеры во время выполнения. Но все блоки освобождатся, когда Вы выходите из функции из которой alloca вызывалась,как если бы они были динамические локальные переменные, объявленные в этой функции. Не имеется никакого способа освободить место явно.
Прототип для alloca находится в "stdlib.h". Эта функция - BSD расширение.
void * alloca (size _t size); (функция)
Не используйте alloca внутри аргументов обращения к функции, Вы получите непредсказуемые результаты, потому что стек-пространство для alloca появится на стеке в середине пространства для аргументов функции. Пример того, что нужно избегать - foo (x, alloca (4), y).
Пример использования alloca, это функция, которая открывает имя файла, сделанное из связывания двух строк аргумента, и возвращает описатель файла или минус один выражая отказ:
intopen2 (char * str1, char * str2, int flags, int mode)
{
char *name = (char *) alloca (strlen (str1) + strlen (str2) + 1);
strcpy (name, str1);
strcat (name, str2);
return open (name, flags, mode);
}
intopen2 (char * str1, char * str2, int flags, int mode)
{
char *name = (char *) malloc (strlen (str1) + strlen (str2) + 1);
int desc;
if (name == 0) fatal ("превышенна виртуальная память ");
strcpy (name, str1);
strcat (name, str2);
desc = (name, flags, mode);
free (name);
desc;
}
Имеются причины, почему alloca может быть предпочтительнее malloc:
intopen2 (char * str1, char * str2, int flags, int mode)
{
char *name = (char *) alloca (strlen (str1) + strlen (str2) + 1);
strcpy (name, str1); strcat (name, str2);
return open_or_report_error (name, flags, mode);
}
А предыдущее определение open2 (которое использует malloc и free) допустило бы утечку памяти, если это было бы изменено таким образом,. Даже если Вы хотите сделать большее количество изменений, чтобы устранить это, не имеется никакого простого способа делать так.
Здесь недостатки alloca по сравнению с malloc:
В GNU C, Вы можете заменять большинство использований alloca с массивом переменного размера. Вот, как выглядела бы open2:
int open2(char * str1, char * str2, int flags, int mode)
{
char name [strlen (str1) + strlen(str2) + 1];
strcpy (name, str1);
strcat (name, str2);
return open (name, flags,mode);
}
Любая система динамического распределения памяти имеет непроизводительные затраты: количество места, которое она использует больше чем количество, о котором программа просит. Программа настройки распределения памяти достигает очень низких непроизводительных затрат, перемещая блоки в памяти по мере необходимости, по собственной инициативе.
Когда Вы резервируете блок malloc, адрес блока никогда не изменяется, если Вы не используете realloc, чтобы изменить размер. Таким образом, Вы можете безопасно сохранять адрес в различных местах, временно или постоянно, как захотите. Это не безопасно, когда Вы используете программу настройки распределения памяти, потому что любые переместимые блоки могут двигаться всякий раз, когда Вы зарезервируете память в любом режиме. Даже вызов malloc или realloc может перемещать переместимые блоки.
Для каждого переместимого блока, Вы должны делать дескриптор указываемого объекта в памяти, предназначенный для того, чтобы сохранять адрес этого блока. Программа настройки распределения знает, где находится дескриптор каждого блока, и модифицирует адрес, сохраненный там всякий раз, когда она перемещает блок, так, чтобы дескриптор всегда указывал на блок. Каждый раз Вы обращаетесь к содержимому блока, Вы должны брать адрес из дескриптора.
Вызов любой функции программы настройки распределения из обработчика сигнала почти всегда неправилен, потому что сигнал мог появиться в любое время. Единственый способ делать это безопасно состоит в том, чтобы блокировать сигнал для любого доступа к содержимому любого переместимого блока, не удобен для работы. См. раздел 21.4.6 [Неповторное вхождение].
В описаниях ниже, handleptr обозначает адрес дескриптора. Все функции объявлены в "malloc.h"; все являются расширениями GNU.
void * r_alloc (void ** handleptr, size _t size) (функция)
Если r_alloc не может получить необходимое место, она сохраняет пустой указатель в *handleptr, и возвращает пустой указатель.
void r_alloc_free (void ** handleptr) (функция)
void * r_re_alloc (void ** handleptr, size _t size) (функция)
Если достаточная память не доступна, эта функция, возвращает пустой указатель и не изменяет *handleptr.
Вы можете просить о предупреждениях для программ исчерпывающих пространство памяти, вызывая memory_warnings. Она указывает, чтобы malloc проверял использование памяти, каждый раз когда он просит о большем количестве памяти из операционной системы. Это - расширение GNU, объявленное в "malloc.h".
void memory_warnings (void *start, void (* warn_func) (const char*)) (функция)
Аргумент start говорит, где начинается место данных в памяти. Программа распределения сравнивает его c последним используемым адресом и с пределом места данных, определяя долю доступной памяти. Если Вы указываете нуль как начало, то по умолчанию, используется наиболее вероятное значение.
malloc может вызывать функцию warn_func, чтобы предупредить Вас. Она вызывается со строкой (предупреждающим сообщением) как аргументом. Обычно она должнаот образить строку для пользователя.
Предупреждения приходят, когда память становится полной на 75%, на 85%, и на 95%. Если занято более чем 95 % Вы получаете другое предупреждение каждый раз увеличивая используемую память.
Программы которве работтают с символами и строками часто должны классифицировать символ как букву, цифру, пробел, и так далее и выполнять операции замены регистра на символах. Функции в заголовочном файле "ctype.h" предусмотрены для этой цели.
Так как выбор стандарта и набора символов может изменять классификации специфических символьных кодов, все эти функции зависят от текущего стандарта. (Точнее, на них воздействует стандарт, в настоящее время выбранный для классификации символов LC_CTYPE; см. раздел 19.3 [Категории стандарта] )
Этот раздел объясняет библиотечные функции для классификации символов. Например, isalpha - функция, чтобы проверить буквенный ли символ. Она имеет один аргумент, символ для проверки, и возвращает целое число отличное от нуля, если символ буквенный, и нуль иначе. Ее можно использовть примерно так:
if (isalpha (c)) printf ("Символ \"%c\" является буквой.\n", c);
Атрибуты любого данного символа могут измениться между стандартами. См. Главу 19 [Стандарты], для уточнения информации относительно стандартов.
Эти функции объявлены в заголовочном файле "ctype.h".
Возвращает истину, если C - символ нижнего регистра.
Возвращает истину, если C - символ верхнего регистра.
Возвращает истину, если C - буквенный символ (буква). Если islower или isupper - истина для символа, то isalpha - также истина.
В некоторых стандартах , могут иметься дополнительные символы, для которых isalpha является истинной, и которые не являются, ни строчными буквами, ни символами верхнего регистра. Но в стандарте "C", не имеется никаких таких дополнительных символов.
Возвращает истину, если C - десятичная цифра (от "0" до "9").
Возвращает истину, если C - алфавитно-цифровой символ (символ или цифра); другими словами, если или isalpha или isdigit - истина для символа, то isalnum - также истина.
Возвращает истину, если C - шестнадцатеричная цифра. Шестнадцатеричные цифры включают нормальные десятичные цифры от "0" до "9" и символы от "А" до "F" и от "a" до "f".
Возвращает истину, если C - символ пунктуации. Это означает любой символ печати, который не алфавитно-цифровой или пробел.
Возвращает истину, если C - символ пропуска. В стандартном расположении, isspace возвращает истину только для стандартных символов пробела:
" " пробел
"\f" перевод страницы
"\n" символ перевода строки
"\r" возврат каретки
"\t" горизонтальная метка табуляции
"\v" вертикальная метка табуляции
Возвращает истину, если C - знак пропуска; то есть пробел или метка табуляции. Эта функция - расширение GNU.
Возвращает истину, если C - графический символ; то есть символ, который имеет glyph, связанный с этим. Символы пропуска не рассматриваются как графические символы.
Возвращает истину, если C - символ печати. Символы печати включают все графические символы, плюс пробел (" ").
Возвращает истину, если C - управляющий символ (то есть символ, который не является символом печати).
Возвращает истину, если C 7-битовое символьное значение без знака, которое вписываться в US/UK ASCII набор символов. Эта функция - BSD расширение и - также SVID расширение.
Этот раздел объясняет библиотечные функции для выполнения преобразований типа замены регистра символаов. Например, toupper преобразовывает любой символ в верхний регистр если возможно. Если символ не может быть преобразован, toupper, возвращает его неизменным.
Эти функции берут один аргумент типа int, который является символом, чтобы преобразовывать, и возвратить преобразованный символ как int. Если преобразование не применимо данному аргументу, аргумент, возвращается неизмененным.
Примечание относительно совместимости: В до-ANSI диалектах C, вместо того, чтобы возвращать неизмененный аргумент, эти функции могут терпеть неудачу, когда аргумент не подит для преобразования. Таким образом для переносимости, Вы должны написать islower (c)? toupper (c): c) а не просто toupper (c).
Эти функции объявлены в заголовочном файле "ctype.h".
Если C - символ верхнего регистра, tolower возвращает соответствующий символ нижнего регистра. C если - не символ верхнего регистра, C возвращается неизменным.
Если С - символ нижнего регистра, tolower возвращает соответствующий символ верхнего регистра. Иначе C возвращается неизменным.
Эта функция преобразовывает C в ASCII символ, очищая старшие биты. Эта функция - BSD расширение и - также SVID расширение.
Она идентична tolower, и предусматривает совместимость с SVID. См. раздел 1.2.4 [SVID].
Она идентична toupper, и предусматривает совместимость с SVID.
Операции на строках (или массивах символов) - важная часть многих программ. Библиотека C GNU обеспечивает большой набор строковых сервисных функций, включая функции для копирования, связывания, сравнения, и поиска строк. Многие из этих функций могут также функционировать на произвольных областях памяти; например, функция memcpy может использоваться, чтобы копировать содержимое любого вида массива.
Для начинающихся С программистов довольно обычно "повторно изобретать колесо", дублируя эти функциональные возможности в их собственном коде, но знакомому с библиотечными функциями выгодно использовать их, так как это дает выгоды в эффективности и переносимости.
Например, Вы можете легко сравнивать одну строку с другим в двух строках кода C, но если Вы используете встроенную функцию strcmp, менее вероятно, что Вы сделаете ошибку. И, так как эти библиотечные функции обычно сильно оптимизированы, ваша программа может выполняться быстрее.
Этот раздел - быстрый обзор строковых понятий для начинающих программистов. Он описывает, как символьные строки представляются на C. Если Вы уже знакомы с этим материалом, Вы можете пропустить этот раздел.
Строка - массив объектов char. Но строковые переменные, обычно объявляется, как указатели типа char *. Такие переменные не включают пространство для текста строки; он должен быть сохранен где-нибудь в переменной типа массив, строковой константе, или динамически размещенной памяти (см. Главу 3 [Распределение памяти]). Это позволяет Вам сохранить адрес выбранного пространства памяти в переменнуюуказатель. В качестве альтернативы Вы можете сохранять пустой указатель в переменной. Пустой указатель никуда не указывает, так что попытка сослаться на строку, на которую он указывает, получит ошибку.
Обычно, пустой символ, "\0", отмечает конец строки. Например, в тестировании, чтобы видеть, что переменная p указывает на пустой символ, отмечающий конец строки, Вы можете написать ! * P или * p == "\0".
Пустой символ - совершенно отличен от пустого указателя, хотя, и представляется целым числом 0.
Строковые литералы появляются в C программе как строки символов между символами кавычек ('"'). В ANSI C, строковые литералы могут также быть сформированы строковой конкатенацией: "a" "b" - то же что "ab". Изменение строковых литералов не допускается GNU С компилятором, потому что литералы помещены в памяти только для чтения.
Символьные массивы, которые являются объявленным const, также не могут изменяться. Это - вообще хороший стиль, объявить, что немодифицируемые строковые указатели будут типа const char *, так как это часто позволяет компилятору C обнаружить случайные изменения, также как обеспечение некоторого количества документации относительно того, что ваша программа предполагает делать со строкой.
Объем памяти, размещенный для символьного массива может простираться после пустого символа, который обычно отмечает конец строки. В этом документе термин размер резервирования всегда используется, чтобы обратиться к общей сумме памяти, размещенной для строки, в то время как термин длина относится к числу символов до (но не, включая) пустого символа завершения.
Известным источником ошибок является то, что программа пробует помещать большее количество символов в строку чем позволяет размещенный размер. При написании кода, который расширяет строки или перемещает символы в массив, Вы должны быть очень осторожны, чтобы следить за длиной текста и делать явную проверку переполнения массива. Многие из библиотечных функций не делают это для Вас! Не забудьте также, что Вы должны зарезервировать дополнительный байт, чтобы содержать пустой символ, который отмечает конец строки.
Эта глава описывает функции, которые работают над произвольными массивами или блоками памяти, и функции, которые являются специфическими для массивов с нулевым символом в конце.
Функции, которые функционируют на произвольных блоках памяти, имеют имена, начинающиеся "mem" (типа memcpy) и неизменно имеют аргумент, который определяет размер (в байтах) блока рабочей памяти. Аргументы массива и возвращаемые значения для этих функций имеют тип void*, и как стиль, элементы этих массивов упоминаются как "байты". Вы можете передавать любой вид указателя на эти функции, а оператор sizeof полезен при вычислении значения аргумента size.
Напротив, функции, которые функционируют специально на строках, имеют имена, начинающиеся "str" (типа strcpy) и ищут пустой символ, чтобы завершить строку вместо того, чтобы требовать, чтобы был передан явный аргумент размера. (Некоторые из этих функций принимают заданную максимальную длину, но они также проверяют преждевременное окончание с пустым символом.) аргументы массива и возвращаемые значения для этих функций имеют тип char *, и элементы массива упоминаются как "символы".
В многих случаях, имеется, и "mem" и "str" версии функции. Которая является более подходящей, зависит от контекста. Когда ваша программа манипулирует произвольными массивами или блоками памяти, Вы должны всегда использовать "mem" функции. С другой стороны, когда Вы манипулируете строками с нулевым символом в конце, обычно более удобно использовать "str" функции, если Вы не знаете длину строки заранее.
Вы можете получить длину строки, используя функцию strlen. Эта функция объявлена в заголовочном файле "string.h".
size _t strlen (const char * s) (функция)
strlen ("привет, мир") =>12
Когда функция strlen применяется к символьному массиву, она возвращает длину сохраненной строки, а не размер резервирования. Вы можете получить размер резервирования символьного массива, который содержит строку, используя оператор sizeof:
char string[32] = "привет, мир"; sizeof (string) => 32 strlen (string) => 12
Вы можете использовать функции, описанные в этом разделе, чтобы копировать содержимое строк и массивов, или конкатенировать содержимое одной строки c другой. Эти функции объявлены в заголовочном файле "string.h".
Все эти функции возвращают адрес целевого массива.
Большинство этих функций не работает правильно, если исходный и целевой массивы накладываются. Например, если начало массива адресата накладывается на конец исходного массива, первоначальное содержимое той части исходного массива может стать записанным поверх прежде, чем это скопировано. Даже хуже, в случае строковых функций, пустой символ, отмечающий конец строки можно потерять, и функция копирования может эастревать в цикле, просматривая всю память зарезервированную для вашей программы.
Все функции, которые имеют проблемы при копировании между накладывающимися массивами, явно идентифицированы в этом руководстве. В дополнение к функциям в этом разделе, имеется несколько, других например sprintf (см. раздел 7.9.7 [Форматируемые функции вывода]) и scanf (см. раздел 7.11.8 [Форматируемые функции ввода]).
void * memcpy (void *to, void const *from, size _t size) (функция)
Значение, возвращенное memcpy - значение to.
Вот пример того, как Вы могли бы использовать memcpy, чтобы копировать содержимое массива:
struct foo *oldarray, *newarray;
int arraysize;
...
memcpy (new, old, arraysize * sizeof (struct foo));
void * memmove (void *to, void const *from, size _t size) (функция)
void * memccpy (void *to, void const *from, int C, size _t size) (функция)
void * memset (void * block, int C, size _t size) (функция)
сhar * strcpy (char *to, const char *from) (функция)
char * strncpy (char *to, const char *from, size _t size) (функция)
Если длина from - больше чем size, то strncpy копирует только первые size символов.
Если длина from меньше чем size, то strncpy, копирует все from, сопровождая его достаточным количеством пустых символов, чтобы получить всего size символов. Это редко полезно, но зато определено в соответствии c ANSI стандартом.
Поведение strncpy неопределено, если строки накладываются.
Использование strncpy в противоположность strcpy - способ избежать ошибок в отношении соглашения о записи после конца размещенного пространства для to. Однако, это может также сделать вашу программу намного медленнее в одном общем случае: копирование строки, которая является возможно малой в потенциально большой буфер. В этом случае, size может быть большой, и когда это, strncpy будет тратить впустую значительное количество времени, копируя пустые символы.
char * strdup (const char * s) (функция)
Если malloc не может зарезервировать пространство для новой строки, strdup возвращает пустой указатель. Иначе она возвращает указатель на новую строку.
char * stpcpy (char *to, const char *from) (функция)
Например, эта программа использует stpcpy, чтобы конкатенировать "foo" и "bar" и печатает "foobar".
#include <string.h>
#include <stdio.h>
intmain (void)
{
char buffer[10];
char *to = buffer;
to = stpcpy (to, "foo");
to = stpcpy (to, "bar");
puts (buffer);
return 0;
}
Поведение неопределено, если строки накладываются.
сhar * strcat (char * to, const char *from) (функция)
Эквивалентное определение для strcat было бы:
char * strcat (char *to, const char *from)
{
strcpy (to + strlen to, from);
return to;
}
char * strncat (char *to, const char *from, size _t size) (функция)
Функция strncat могла быть выполнена примерно так:
char * strncat (char *to, const char *from, size_t size)
{
strncpy (to + strlen (to), from, size);
return to;
}
Вот пример, показывающий использование strncpy и strncat. Обратите внимание, как вычислен параметр size, в обращении к strncat, чтобы избежать переполнять символьный массив buffer.
#include <string.h>
#include <stdio.h>
#define SIZE 10
static char buffer[SIZE];
main ()
{
strncpy (buffer, "hello", SIZE);
puts (buffer);
strncat (buffer, ", world", SIZE - strlen (buffer) - 1);
puts (buffer);
}
hellohello, wo
void * bcopy (void *from, void const *to, size _t size) (функция)
void * bzero (void *block, size _t size) (функция)
Вы можете использовать функции в этого раздела, чтобы выполнить сравнение на содержимое строк и массивов. Также как для проверки равенства, эти функции могут использоваться как функции упорядочения для операций сортировки. См. Главу 15 [Поиск и сортировка].
В отличие от большинства операций сравнения в C, строковые функции сравнения возвращают значение отличное от нуля, если строки - не эквивалентны. Знак значения указывает относительное упорядочение первых символов в строках, которые - не эквивалентны: отрицательное значение указывает, что первая строка - "меньше" чем вторая, в то время как положительное значение указывает, что первая строка "больше".
Если Вы используете эти функции только, чтобы проверить равенство, для большей чистоты программы, лучше задать их как макроопределения, примерно так:
#define str_eq (s1, s2) (! Strcmp ((s1), (s2)))
int memcmp (void const * a1, void const * a2, size _t size) (функция)
Если содержимое двух блоков равно, memcmp, возвращает 0.
На произвольных массивах, функция memcmp обычно полезна для тестирования равенства. Обычно не имеет смысла делать байтовое сравнение упорядочения на не байтовых массивах. Например, байтовое сравнение на байтах, которые составляют числа с плавающей запятой не должно правдоподобно сообщить Вам что - нибудь относительно связи между значениями чисел с плавающей запятой.
Вы должны также быть внимательны при использовании memcmp, для сравнения объектов, которые могут содержать "дырки", типа дополнения, вставленного в объекты структуры, чтобы предписать требования выравнивания, дополнительного пространства в конце объединений, и дополнительных символов в концах строк, чьи длины меньше чем затребовано при размещении.
Содержимое этих "дырок" неопределено и может вызывать странное поведение при выполнении байтового сравнения. Для более предсказуемых результатов, выполните явное покомпонентное сравнение.
Например, пусть дано определение типов структуры подобно:
struct foo {
unsigned char tag;
union{double f; long i; char *p;}
value;
};
int strcmp (const char * s1, const char * s2) (функция)
Если две строки равны, strcmp, возвращает 0.
Следствие упорядочения, используемого strcmp - то, что, если s1 является начальной подстрокой s2, то s1 "меньше чем" s2.
int strcasecmp (const char * s1, const char * s2) (функция)
strcasecmp происходит от BSD.
int strncasecmp (const char * s1, const char * s2) (функция)
strncasecmp - расширение GNU.
int strncmp (const char * s1, const char * s2, size _t size) (функция)
Имеются некоторые примеры, показывающие использование strcmp и strncmp. Эти примеры подразумевают использование набора символов ASCII. (Если используется некоторый другой набор символов скажем, расширенный двоично-десятичный код обмена информацией, взамен, то glyphs связаны с различными числовыми кодами, и возвращаемые значения, и порядок могут отличиться.)
strcmp ("привет", "привет")
=> 0 /* Эти две строки одинаковы. */
strcmp ("привет", "Привет")
=> 33 /* Сравнение чувствительно к регистру. */
strcmp ("привет", "мир")
=> -2 /* символ "п" меньше чем "м". */
strcmp ("привет", "привет, мир")
=> -44 /* Сравнение пустого символа с запятой. */
strncmp ("привет", "привет, мир", 5)
=> 0 /* начальные 5 символов - те же самые. */
strncmp ("привет, мир","привет, глупый мир!!!", 5)
=> 0 /* начальные 5 символов - те же самые. */
int bcmp (void const * a1, void const * a2, size _t size) (функция)
В некоторых местах соглашения лексикографического упорядочения отличаются от строгого числового упорядочения символьных кодов. Например, в Испании большинство букв с диакритическими знаками, но буквы с диакритическими знаками не считаются различными символами в целях объединения. С другой стороны, последовательность с двумя символами "ll" обрабатывается как одна буква, которая объединена с "l".
Вы можете использовать функции strcoll и strxfrm (объявленные в заголовочном файле "string.h") чтобы сравнивать строки, использующие объединение упорядочивания соответствующее для данной местности. Стандарт, используемое этими функциями в частности может быть определено, устанавливая стандарт для класса LC_COLLATE; см. Главу 19 [Стандарты].
В стандартном расположении C, последовательность объединений для strcoll - таже что для strcmp.
Действительно, способ, которым эта функция работает применяя отображение, чтобы трансформировать символы в строку, в последовательность байтов которая представляет позицию строки в последовательности объединений текущего расположения. Сравнение двух таких последовательностей байтов в простом режиме эквивалентно сравнению строк с последовательностью объединений расположения.
Функция strcoll выполняет эту трансляцию неявно, чтобы делать одно сравнение. А, strxfrm выполняет отображение явно. Если Вы делаете многократное сравнение, используя ту же самую строку или набор строк, то более эффективноиспользовать strxfrm, чтобы трансформировать все строки только один раз, и впоследствии сравнивать преобразованные строки strcmp.
int strcoll (const char * s1, const char * s2) (функция)
Вот пример сортировки массива строк, с использованием strcoll, чтобы сравнить их. Фактический алгоритм сортировки здесь не написан; он исходит из qsort (см. раздел 15.3 [Функции сортировки массива]). Работа кода показанного здесь, говорит, как сравнивать строки при их сортировке. (Позже в этом разделе, мы покажем способ делать это, более эффективно используя strxfrm.)
/* Это - функция сравнения, используемая в qsort. */
intcompare_elements (char **p1, char **p2)
{
return strcoll (*p1,*p2);
}
/* Это - точка входа к функции сортировки строк, использующей
последовательность объединений расположения. */
void sort_strings (char **array, int nstrings)
{ /* Сортировка временного массива, сравнивая строки. */
qsort (array, sizeof (char *), nstrings, compare_elements);
}
size _t strxfrm (char *to, const char *from, size _t size) (функция)
Поведение неопределено если строки to и from перекрываются; см. раздел 5.4 [Копирование и конкатенация].
Возвращаемое значение - длина всей преобразованной строки. На это значение не воздействует значение size, но если она большее чем size, это означает, что преобразованная строка полностью не поместилась в массиве to.
Чтобы получать целую преобразованную строку, вызовите strxfrm снова с большим массивом вывода.
Преобразованная строка может быть больше чем первоначальная строка, а может также быть более короткой.
Если size - нуль, никакие символы не сохранены в to. В этом случае, strxfrm просто возвращает число символов, которое было бы длиной преобразованной строки. Это полезно для определения какую строку зарезервировать. Не имеет значение, что будет в to, если size - нуль; может быть даже пустой указатель.
Вот пример того, как Вы можете использовать strxfrm когда Вы планируете делать много сравнений. Он делает то же самое что и предыдущий пример, но намного быстрее, потому что он должен трансформировать каждую строку только один раз, независимо от того сколько раз она сравнивается с другими строками. Даже времени для резервирования и освобождения памяти нужно намного меньше чем, когда имеются много строк.
struct sorter { char *input; char *transformed; };
/* Это - функция сравнения, используемая qsort для сортировки
массива структур. */
int compare_elements (struct sorter *p1, struct sorter *p2)
{
return strcmp (p1->transformed, p2->transformed);
}
/* Это - точка входа функции сортировки строк, использующей
последовательность объединений расположения. */
void sort_strings_fast (char **array, int nstrings)
{
struct sorter temp_array[nstrings];
int i;
/* Устанавливает temp_array. Каждый элемент содержит одну входную
строку и преобразованную строку. */
for (i = 0; i < nstrings; i++)
{
size_t length = strlen (array[i]) * 2;
temp_array[i].input = array[i];
/* Трансформирует array[i] . Сначала, пробует буфер, возможно
достаточно большой. */
while (1)
{
char *transformed = (char *) xmalloc (length);
if (strxfrm (transformed, array[i], length) < length)
{
temp_array[i].transformed = transformed;
break;
} /* Попытка снова с еще большим буфером. */
free (transformed); length *= 2;
}
}
}
/* Сортировка temp_array, сравнивая преобразованные строки. */
qsort (temp_array, sizeof (struct sorter), nstrings,
compare_elements);
/* Помещает элементы обратно в постоянный массив в их сортированном
порядке. */
for (i = 0; i < nstrings; i++) array[i] = temp_array[i].input;
/* Освобождают строки, которые мы зарезервировали. */
for (i = 0; i < nstrings; i++) free (temp_array[i].transformed);}
Этот раздел описывает библиотечные функции, которые выполняют различные виды операций поиска в строках и массивах. Эти функции объявлены в заголовочном файле "string.h".
void * memchr (void const *block, int с, size _t size) (функция)
сhar * strchr (const char *string, int c) (функция)
Например,
strchr ("привет, мир", "в")
=> "вет, мир"
strchr ("привет, мир", "?")
=> NULL
char * index (const char *string, int c) (функция) - другое имя для strchr.
сhar * strrchr (const char *string, int c) (функция)
Например,
strrchr ("привет, мир", "и")
=> "ир"
char * rindex (const char *string, int c) (функция)
char * strstr (const char * haystack, const char * needle) (функция)
Например,
strstr ("привет, мир","в")
=> "вет, мир"
trstr ("привет, мир","ми")
=> "мир"
Она подобна strstr, но needle и haystack байтовые массивы, а не строки с нулевым символом в конце. needle_len - длина needle, а haystack_len - длина haystack.
Эта функция - расширение GNU.
size_t strspn (const char *string, const char *skipset) (функция)
Например,
strspn ("привет, мир","абвгдежзийклмнопрстуфхцчшщъыьэюя"))
=> 6
size_t strcspn (const char *string, const char *stopset) (функция)
Например,
strcspn ("привет, мир","\t\n,.;!?")
=> 6
char * strpbrk (const char *string, const char *stopset) (функция)
Например,
strpbrk ("привет, мир","\t\n,.;!?")
=> ",мир"
В программах довольно часто возникает потребность сделать некоторые простые виды лексического и синтаксического анализа, типа разбивания командной строки в лексемы. Вы можете делать это функцией strtok, объявленной в заголовочном файле "string.h".
char * strtok (char *newstring, const char *delimiters) (функция)
Строка, которую нужно разбивать передается как newstring только при первом обращении. Функция strtok использует ее, чтобы установить некоторую внутреннюю информацию о состоянии. Последующие обращения, чтобы получить дополнительные лексемы из той же самой строки обозначаются передачей пустого указателя как аргумента. Вызов strtok с другим не-пустым символом newstring повторно инициализирует информацию о состоянии. Гарантируется, что никакая другая библиотечная функция (которая смешала бы эту внутреннюю информацию о состоянии) никогда не вызовет strtok.
Аргумент delimiters - строка, которая определяет набор разделителей, которые могут окружать извлекаемую лексему. Все начальные символы, которые являются элементами этого набора, отбрасываются. Первый символ, который не является элементом этого набора разделителей, отмечает начало следующей лексемы. Конец лексемы находится, как следующий символ, который является элементом набора разделителей. Этот символ в первоначальной строке newstring зменяется пустым символом, и возвращается указатель на начало лексемы в newstring.
При следующем обращении к strtok, поиск начинается со следующего символа после того который отмечен концом предыдущей лексемы. Обратите внимание, что набор разделителей не должен быть тем же самым при каждом вызове strtok.
Если конец строки newstring достигнут, или если остаточный член от строки состоит только из символов - разделителей, strtok, возвращает пустой указатель.
Предупреждение: С тех пор как strtok изменит строку, которую она анализирует, всегда копируйте строку во временный буфер перед синтаксическим ее анализом strtok. Если Вы разрешаете, чтобы strtok изменил строку, которая исходила из другой части вашей программы, Вы создаете проблему; та строка может быть частью структуры данных, которая могла использоваться для других целей в течение синтаксического анализа, в то время как чередование strtok делает структуру данных, временно неточной.
Строка, на которой Вы действуете, могла быть и константой. И, когда strtok попробует изменять ее, ваша программа получит фатальный сигнал о записи в память распределенную тоько для чтения. См. раздел 21.2.1 [Сигналы ошибки в программе].
Это - частный случай общего принципа: если часть программы не имеет цели изменить некоторую структуру данных, то ошибочно изменять структуру данных даже временно.
Функция strtok не повторно используема. См. раздел 21.4.6 [Неповторная входимость], для обсуждения где и почему повторная входимость важна.
Вот простой пример, показывающий использование strtok.
#include <string.h>
#include <stddef.h>
. . .
char string[] = "words separated by spaces -- and, punctuation!";
const char delimiters[] = " .,;:!-";
char *token;
. . .
token = strtok (string, delimiters); /* token => "words" */
token = strtok (NULL, delimiters); /* token => "separated" */
token = strtok (NULL, delimiters); /* token => "by" */
token = strtok (NULL, delimiters); /* token => "spaces" */
token = strtok (NULL, delimiters); /* token => "and" */
token = strtok (NULL, delimiters); /* token => "punctuation" */
token = strtok (NULL, delimiters); /* token => NULL */
Большинство программ должно делать некоторый ввод (чтение данных) или вывод, или наиболее часто оба, чтобы сделать что-нибудь полезное. Библиотека GNU С обеспечивает такой большой выбор функций ввода и функций вывода, что самая трудная часть решить, которая функция является наиболее подходящей!
Эта глава представляет понятия и терминологию, имеющие отношение к вводу и выводу. Другие главы, имеющие отношение к средствам ввода-вывода GNU:
Прежде, чем Вы сможете читать или писать содержимое файла, Вы должны установить соединение или канал связи с файлом. Этот процесс называется открытием файла. Вы можете открывать файл для чтения, записи, или для того и другого.
Соединение с открытым файлом представляется или как поток или как описатель файла. Вы передаете его как аргумент функциям, которые делают фактическое чтение или операции записи. Некоторые функции ожидают потоки, а некоторые разработаны для взаимодействия с описателями файла.
Когда Вы закончили читать из или писать в файл, Вы можете завершать соединение, закрывая файл. Если только Вы закрыли поток или описатель файла, Вы не можете больше делать операции ввода-вывода на нем.
Когда Вы хотите осуществлять ввод или выводить в файл, Вы имеете выбор из двух базисных механизмов для представления соединения между вашей программой и файлом. Это описатели файла и потоки. Описатели файла представляются как объекты типа int, в то время как потоки представляются как объекты FILE* (указатели).
Описатели файла обеспечивают примитивный интерфейс низкого уровня для операций ввода и вывода. И описатели файла, и потоки могут представлять соединение с устройством (типа терминала), или с трубопрводом или с гнездом для сообщения с другим процессом, также как с нормальным файлом. Но, если Вы хотите осуществлять операции управления, которые являются специфическими для специфического вида устройства, Вы должны использовать описатель файла; не имеется никаких средств, чтобы использовать для этого потоки. Вы должны также использовать описатели файла, если ваша программа должна делать ввод или выводить в специальных режимах, типа неблокированный (или опрошенный) ввод (см. раздел 8.10 [Флаги состояния файла]).
Потоки обеспечивают интерфейс более высокого уровня, основанный на примитивных средствах описателя файла. Интерфейс потока хорошо обрабатывает все виды файлов, единственная сложность - три стиля буферизации, которую Вы можете выбирать (см. раздел 7.17 [Буферизация потока]).
Основное преимущество использования интерфейса потока - то, что набор функций для выполнения фактического ввода и вывода (в противоположность операциям управления) на потоках является намного более богатым и более мощным чем соответствующие средства для описателей файла. Интерфейс описателя файла обеспечивает только простые функции для пересылки блоков символов, а интерфейс потока обеспечивает мощный форматируемый ввод и вывода (printf и scanf) также как функции для символьно- и строко- ориентированного ввода и вывода.
Так как потоки выполнены в терминах описателей файла, Вы можете извлекать описатель файла из потока и выполнять операции низкого уровня непосредственно на описателе файла. Вы можете также первоначально открывать соединение как описатель файла, а потом делать поток, связанный с этим описателем файла.
Вообще, Вы должны ограничиться использованием потоков, если не имеется некоторой специфической операции, которая может быть выполнена только на описателе файла. Если Вы - начинающий программист и не уверены, какие функции использовать, мы предлагаем Вам концентрироваться на форматируемых функциях (см. раздел 7.11 [Форматируемый ввод] и раздел 7.9 [Форматируемый вывод]).
Если Вы думаете о переносимости ваших программ на не-GNU системы, Вы должны также осознавать, что описатели файла не так переносимы как потоки. Вы можете ожидать что любая ANSI система поддерживает потоки, но не-GNU системы не могут поддерживать описатели файла вообще или могут выполнять только подмножество функций GNU, которые функционируют на описателях файла. Большинство функций описателя файла в библиотеке GNU включено в стандарт POSIX.1.
Один из атрибутов открытого файла - позиция файла, которая следит, где в файле следующий символ должен прочитаться или написаться. В системе GNU, и всех POSIX.1 системах, позиция файла - просто целое число, представляющее число байтов от начала файла.
Позиция файла обычно устанавливается в начало файла, когда он открыт, и каждый раз когда символ читается или пишется, позиция файла увеличивается. Другими словами, доступ к файлу обычно последователен.
Обычные файлы разрешают чтение или запись в любую позицию внутри файла. Некоторые другие виды файлов могут также разрешать это. Файлы, которые разрешают это иногда упоминаются как файлы прямого доступа. Вы можете изменять позицию файла, используя функцию fseek на потоке (см. раздел 7.15 [Позиционирование файла]) или функцию lseek на описателе файла (см. раздел 8.2 [Примитивы ввода - вывода]). Если Вы пробуете изменять позицию файла в файле, который не поддерживает произвольный доступ, Вы получите ошибку ESPIPE.
Потоки и описатели, которые открыты для дописывания обрабатываются особенно для вывода: вывод в такие файлы всегда конкатенируется последовательно к концу файла, независимо от позиции файла. Но, позиция файла все еще используется, чтобы управлять, где в файле производить выполняемое чтение.
Если Вы подумаете относительно этого, вы поймете, что несколько программ могут читать данный файл в то же самое время. Каждая программа должна иметь собственный указатель файла, на который не воздействует ничего из того, что делают другие программы.
Фактически, каждое открытие файла создает отдельную позицию файла. Таким образом, если Вы открываете файл дважды даже в той же самой программе, Вы получаете два потока или описатели с независимыми позициями файла.
Напротив, если Вы открываете описатель а потом дублируете его, чтобы получить другой описатель, эти два описателя совместно используют ту же самую позицию файла: изменение позиции файла одного описателя будет воздействовать на другой.
Чтобы открывать соединение с файлом, или выполнять другие операции типа удаления файла, Вы нуждаетесь в некотором способе обращения к файлу. Почти все файлы имеют имена, которые представляются строками.
Эти строки называются именами файла. Вы определяете имя файла, чтобы указывать, который файл Вы хотите открыть или обработать.
Этот раздел описывает соглашения для имен файла и как операционная система работает с ними.
Чтобы понимать синтаксис имен файла, Вы должны понять, как файловая система организована посредством иерархии каталогов.
Каталог - это файл, который содержит информацию, связыывающую имена других файлов; эти ассоциации называются выходами каталога или узами. Иногда, люди говорят "файлы в каталоге", но фактически, каталог только содержит указатели на файлы, а не файлы непосредственно.
Имя каталога содержащего файл, называется компонентом имени файла. Вообще, имя файла это последовательность из одного или большего количества таких компонентов, отделяемых символом наклонной черты вправо ("/").
Некоторые другие документы, типа POSIX стандарта, используют термин путь для того, что мы называем имя файла, и компонент пути для того, что это руководство вызывает компонент имени файла. Мы не используем эту терминологию, потому что "путь" - это что-нибудь полностью отличное (список каталогов для поиска), и мы думаем, что "имя пути", используемое для чего-нибудь еще будет запутывать пользователей. В документации GNU мы всегда используем "имя файла" и "компонент имени файла" (или иногда только "компонент", где контекст очевиден).
Вы можете найти более детализированную информацию относительно операций с каталогами в Главе 9 [Интерфейс файловой системы].
Имя файла состоит из компонентов имени файла, отделяемых наклонной чертой вправо ("/"). В системах, которые поддерживает библиотека GNU С, многократные последовательные символы `/' эквивалентны одиночному символу `/'.
Процесс определения, к какому файлу относится имя файла называется назначение имени файла. Это реализуется, исследованием компонентов, которые составляют имя файла слева направо, и размещением каждого последовательныого компонента в каталоге, именованном предыдущим компонентом. Конечно, каждый из файлов, которые названы каталогами, должен фактически существовать, и быть каталогом вместо регулярного файла, и иметь соответствующие права, чтобы быть доступным различным процессам; иначе неправильно назначено имя файла.
Если, имя файла начинается с "/", первым компонентом в имени файла принимается корневой каталог процесса (обычно все процессы в системе имеют тот же самый корневой каталог). Такое имя файла называется абсолютным именем файла.
Иначе, первый компонент в имени файла есть текущий рабочий каталог (см. раздел 9.1 [Рабочий каталог]). Этот вид имени файла называется именем файла прямого доступа.
Компоненты имени файла "." ("точка") и ".." ("точка - точка") имеют специальные значения. Каждый каталог имеет входы для этих компонентов имени файла. Компонент имени файла "." относится к каталогу непосредственно, в то время как компонент имени файла ".." относится к каталогу предыдущего уровня (каталог, который содержит связь для рассматриваемого каталога). Как частный случай, ".." в корневом каталоге относится к корневому каталогу непосредственно, так как он не имеет никакого родителя; таким образом "/.." тоже что и "/".
Вот несколько примеров имен файла:
"/a" файл, с именем "а", в корневом каталоге.
"/a/b" файл, с именем "b", в каталоге с именем "а" в корневом каталоге.
"а" файл, с именем "а" в текущем рабочем каталоге.
"/a/./b" Это то же, что и "/a/b".
"./a" файл с именем "а", в текущем рабочем каталоге.
"../a" файл с именем "а", в директории предыдущего уровня текущего
рабочего каталога.
В отличие от некоторых других операционных систем, система GNU не имеет ни какой встроенной поддержки типов файлов (или расширений) или версий как частей синтаксиса имени файла. Много программ и утилит использют соглашения для имен файлов, например, файлы, содержащие исходный текст C обычно имеют имена, с прибавленным ".c" но непосредственно в файловой системе не имеется ничего, что предписывает этот вид соглашения.
Функции, которые принимают как аргументы имена файлов обычно, обнаруживают эти errno - условия ошибки в отношении синтаксиса имени файла. Эти ошибки упоминаются в этом руководство как обычные синтаксические ошибки имени файла.
EACCES
ENAMETOOLONG
В системе GNU, не имеется никакого наложенного ограничения полной длины имени файла, но некоторые файловые системы могут иметь ограничения длины компонента.
ENOENT
ENOTDIR
ELOOP
Правила для синтаксиса имен файла обсуждаемые в разделе 6.2 [Имена файла], являются правилами, обычно используемыми системой GNU и другими POSIX системами. Однако, другие операционные системы могут использовать другие соглашения.
Имеются две причины, почему для Вас важно осознавать проблемы переносимости имени файла:
Стандарт POSIX.1 разрешает, чтобы реализации поместили дополнительные ограничения на синтаксис имени файла, относительно того, какие символы разрешаются в именах файла и на длину имени файла и строк компонентов имени файла. Однако, в системе GNU, Вы не должны волноваться относительно этих ограничений; любой символ за исключением пустого символа допускается в строке имени файла, и не имеется никаких ограничений на длины строк имени файла.
Эта глава описывает функции для создания потоков и выполнения ввода и вывода на них. Как обсждается в Главе 6 [Краткий обзор ввода-вывода], поток - довольно абстрактное понятие, представляющее канал связи с файлом, устройством, или процессом.
По историческим причинам, С тип структуры данных, которая представляет поток называется FILE,а не "поток". Так как большинство библиотечных функций имеет дело с объектами типа FILE *, иногда термина указатель на файл также используется, чтобы обозначить "поток". Это ведет к беспорядку терминологии во многих книгах о C, это руководство, однако, использует термины "файл" и "поток" только в техническом смысле.
Тип FILE объявлен в заголовочном файле "stdio.h".
FILE (тип_данных) - это тип данных, используемый, чтобы представить объекты потока. Объект FILE содержит всю внутреннюю информацию о состоянии относительно соединения со связанным файлом, включая такие вещи как индикатор позиции файла и информация буферизации. Каждый поток также имеет индикаторы ошибки и состояния конца файла, которые могут быть проверены функциями feof и ferror; см. раздел 7.13 [EOF и ошибки].
Объекты FILE размещены и управляются внутренне в соответствии c библиотечными функциями ввода -вывода. Не пробуйте создавать ваши собственные объекты типа FILE; пусть библиотеки, делают это. Ваши программы должны иметь дело только с указателями на эти объекты (то есть FILE*).
Когда основная функция вашей программы вызывается, уже существуют три предопределенных потока. Они представляют "стандартные" входные и выходные каналы, которые были установлены для процесса.
Эти потоки объявлены в заголовочном файле "stdio.h".
стандартный входной поток, который является нормальным источником ввода для программы.
поток стандартного вывода, который используется для нормального вывода программы.
стандартный поток ошибки, который используется для сообщений об ошибках и диагностики, выданной программой.
В библиотеке GNU C, stdin, stdout, и stderr - обычные переменные, которые Вы можете устанавливать точно так же как любые другие. Например, чтобы переназначить стандартный вывод файла, нужно выполнить:
fclose (stdout);
stdout = fopen ("standard-output-file","w");
Открытие файла функцией fopen создает новый поток и устанавливает соединение между потоком и файлом, возможно включая создание нового файла.
Все описанное в этом разделе объявлено в заголовочном файле "stdio.h".
FILE * fopen (const char *filename , const char * opentype) (функция)
оpentype аргумент - это строка, которая управляет открытием файла и определяет атрибуты возникающего в результате потока. Она должна начинаться с одной из следующих последовательностей символов:
"r" Открывает существующий файл для чтения.
"w" Открывает файл для записи. Если файл уже существует, его длина обнуляется. Иначе создается новый файл.
"а" Открывает файл для добавления; то есть записи в конец файла. Если файл уже существует начальное содержимое неизменяется, и вывод потока добавляется в конец файла. Иначе, создается новый пустой файл.
"r+" Открывает существующий файл, и для чтения и для заипси. Начальное содержимое файла неизменяется, и начальная позиция файла - в начале файла.
"w+" Открывает файл, и для чтения и для запмси. Если файл уже существует, он усекается, чтобы обнулить длину. Иначе, создается новый файл.
"а+" Открывает или создают файл, и для чтения и для добавления в конец. Если файл существует, начальное содержимое неизменяется. Иначе, создается новый файл. Начальная позиция файла для чтения - в начале файла, но вывод всегда добавляется к концу файла.
Вы видите, что "а+" запрашивает поток, который может делать и ввод и вывод. Стандарт ANSI говорит, что при использовании такого потока, Вы должны вызвать fflush (см. раздел 7.17 [Буферизация потока]) или позиционирующую файл функцию типа fseek (см. раздел 7.15 [Позиционирование файла]) при переключении чтения на запись или наоборот. Иначе, внутренние буфера не будут освобождены правильно. Библиотека GNU С не имеет этого ограничения; Вы можете делать произвольное чтение и запись на потоке в любом порядке.
Библиотека GNU С определяет один дополнительный символ для использования в opentype: символ "x" настаивает на создании нового файла, если имя файла уже существует, fopen выдаст ошибку. Это эквивалентно O_EXCL опции открыавющей функции (см. раздел 8.10 [Флаги состояния файла]).
Символ "b" в opentype имеет стандартное значение; он запрашивает двоичный поток, а не текстовый поток. Но это не имеет никакое значения в POSIX системах (включая систему GNU). Если и "+" и "b" определен, они могут применяться в любом порядке. См. раздел 7.14 [Двоичные потоки].
Любые другие символы в opentype просто игнорируются. Они могут быть значимы в других системах.
Ели происходит ошибка , fopen возвращает пустой указатель.
Вы можете иметь многократные потоки (или описатели файла) указывающие на тот же самый файл, открытый в то же самое время. Если Вы только вводите, это работает правильно, но Вы должны быть внимательны если какой-то поток выходной. См. раздел 8.5 [Предосторожности, связанные с потоком/описателем].
Это верно в равной степени, в зависимости от того, находятся ли потоки в одной программе или в отдельных программах (что может легко случиться). Может оказаться более безопасным использование средств закрытия файла, для того, чтобы избежать одновременного доступа. См. раздел 8.11 [Блокировки файла].
int FOPEN_MAX (макрос)
FILE * freopen (const char *filename, const char * opentype, FILE *stream) (функция)
Если, если операция терпит неудачу, возвращается пустой указатель; иначе, freopen возвращает поток.
freopen традиционно используется, чтобы соединить стандартный поток типа stdin с файлом вашего собственного выбора. Это полезно в программах, в которых использование стандартного потока для некоторых целей является жестко закодированным. В библиотеке GNU С, Вы можете просто закрывать стандартные потоки и открывать новые через fopen. Но другие системы испытывают недостаток этой способности, так что использование freopen более переносимо.
Когда поток закрывается с помощью fclose, соединение между потоком и файлом отменяется. После того, как Вы закрыли поток, Вы не можете выполнять какие-нибудь дополнительные операции на нем.
int fclose (FILE *stream) (функция)
Важно проверить ошибки, когда Вы вызываете fclose, чтобы закрыть выходной поток, потому что в это время могут быть обнаружены реальные, каждодневные ошибки. Например, когда fclose допишет остающийся буферизированный вывод, это мжет вызвать ошибку, потому что диск полон. Даже если Вы знаете, что буфер пуст, ошибки могут происходить при закрытии файла, если Вы используете NFS.
Функция fclose объявлена в "stdio.h".
Если ваша программа завершается, или если Вы вызываете функцию выхода (см. 22.3.1 [Нормальное окончание]), все открытые потоки автоматически закрываются.
Если ваша программа завершается каким-нибудь другим способом, типа, вызыва функции аварийного прекращения работы (см. раздел 22.3.4 [Прерывание выполнения программы]) или фатального сигнала (см. Главу 21 [Обработка сигналов]), открытые потоки могут быть закрыты неправильно. Буферизированный вывод может быть не дописан. Для подробной информации относительно буферизации потоков, см. раздел 7.17 [Буферизация потока].
Этот раздел описывает функции для выполнения символьно- и строчноориентированного вывода.
Эти функции объявлены в заголовочном файле "stdio.h".
int fputc ( int C, FILE *stream) (функция)
int putc ( int C, FILE *stream) (функция)
int putchar ( int c) (функция)
int fputs (const char * s, FILE *stream) (функция)
Эта функция возвращает EOF, если происходит оибк записи, а иначе неотрицательное значение.
Например:
fputs ("Are ", stdout);
fputs ("you ", stdout);
puts ("hungry?\n", stdout);
int puts (const char * s) (функция)
puts - наиболее удобная функция для печати простых сообщений.
puts ("Это - сообщение.");
int putw ( int w, FILE *stream) (функция)
Этот раздел описывает функции для выполнения символьно- и строчноориентированного ввода. Эти функции объявлены в заголовочном файле "stdio.h".
int fgetc (FILE * stream) (функция)
int getc (FILE * stream) (функция)
int getchar (void) (функция)
Вот пример функции, которая вводит используя fgetc. Она работала бы, точно также используя getc взамен, или используя getchar () вместо fgetc (stdin).
int y_or_n_p (const char *question)
{
fputs (question, stdout);
while (1)
{
int c, answer; /* Напишем пробел, чтобы отделить ответ от вопроса. */
fputc (" ", stdout);
/* Читаем первый символ строки. Это должен быть символ ответа, но
может и не быть. */
c = tolower (fgetc (stdin));
answer = c /* Отбрасываем остальную входную строку. */
while (c != '\n') c = fgetc (stdin);
/* Примем ответ, если он был допустим. */
if (answer == 'y') return 1;
if (answer == 'n') return 0;
/* Ответ был недопустим: просим о допустимом ответе. */
fputs ("Please answer y or n:", stdout);
}
}
int getw (FILE * stream) (функция)
Так как много программ интерпретируют ввод на основе строк, удобно иметь функции, чтобы читать строку из stream.
Стандартный C имеет функции, чтобы делать это, но они не очень безопасны: пустые символы и даже длинные строки могут сбивать их. Библиотека GNU обеспечивает нестандартную функцию getline, которая позволяет читать строки надежно.
Другое расширение GNU, getdelim, обобщает getline. Она читает разграниченную запись, определенную как все после следующего вхождения заданного символа-разделителя.
Все эти функции объявлены в "stdio.h".
size_t getline (char ** lineptr, size _t * n, FILE * stream) (функция)
Перед вызовом getline, Вы должны поместить в *lineptr адрес буфера *n байт длиной, размещенный malloc. Если этот буфер достаточно большой чтобы вместить строку, getline, сохранит строку в этом буфере. Иначе, getline делает больший буфер используя realloc, сохраняя новый буферный адрес обратно в *lineptr и увеличенный size обратно в *n. См. раздел 3.3 [Беспрепятственное резервирование].
Если Вы устанавливаете *lineptr как пустой указатель, и обнуляете *n, перед обращением, то getline, зарезервирует начальный буфер для Вас, вызывая malloc.
В любом случае, когда getline завершается, *lineptr - это char * который указывает на текст строки.
Когда getline успешно завершвется, она возвращает число прочитанных символов (включая символ перевода строки, но не, включая пустой символ завершения). Это значение дает возможность Вам отличить пустые символы, которые являются частью строки от пустого символа, вставленного как признак конца.
Эта функция - расширение GNU, но это - рекомендуемый способ читать строки из stream. Альтернативные стандартные функции ненадежны.
Если происходитошибка происходит или достигнут конец файла, getline возвращает -1.
size_t getdelim (char ** lineptr, size _t * n, int delimiter, FILE * stream) (функция)
Текст сохраняется в lineptr, включая символ - разделитель и пустой символ завершения. Подобно getline, getdelim делает lineptr большим, если он не достаточно большой.
getline фактически реализована в терминах getdelim, как показано ниже:
size_t getline (char **lineptr, size_t *n, FILE *stream)
{
return getdelim (lineptr, n, '\n', stream);
}
сhar * fgets (char * s, int count, FILE * stream) (функция)
Если, система уже в конце файла, когда Вы вызываете fgets, то содержимое массива s, неизменяется, и возвращается пустой указатель. Пустой указатель также возвращается, если происходит ошибка чтения, возвращаемое значение - указатель s.
Предупреждение: если входные данные имеют пустой символ, Вы не может использовать fgets. Так что не используйте fgets, если Вы не знаете, что данные не могут содержать пустой символ. Не используйте ее, чтобы читать файлы, отредактированные пользователем, потому что, если пользователь вставляет пустой символ, Вы должны обработать это правильно или напечатать сообщение об ошибках. Мы рекомендуем использовать getline вместо fgets.
сhar * gets (char * s) (функция)
Предупреждение: эта функция очень опасна, потому что она не обеспечивает никакой защиты против переполнения строки s. Библиотека GNU включает ее только для совместимости. Вы должны всегда использовать fgets или getline взамен. Чтобы напомнить Вам это, компоновщик (при использовании GNU ld) выдаст предупреждение всякий раз, когда Вы используете gets.
В программах синтаксического анализатора часто полезно исследовать следующий символ во входном потокек без того, чтобы удалить его из потока. Это называется "заглядывание вперед" при вводе, потому что ваша программа бросает взгляд на то что она затем будет читать.
При использовании потока ввода - вывода, Вы можете заглядывать вперед при вводе первым чтением и затем обратным чтением (так называемм выталкиванием обратно в поток). Обратное чтение делает символ доступным для следующего обращения к fgetc или другой входной функции на этом потоке.
Это иллюстрированное объяснение обратного чтения. Предположим, что Вы имеете поток, читая файл, который содержит только шесть символов, символы "foobar". Предположите, что Вы пока прочитали три символа. Ситуация выглядит следующим образом:
f o o b а r
^
Если вместо того, чтобы читать "b" Вы выполняете обратное чтение символа "o", Вы получаете примерно такую ситуацию:
f o o b а r
|
o
^
Если Вы обратно читаете "9" вместо "o", Вы получите это:
f o o b а r
|
9
^
Функция для чтения символа обратно называется ungetc, потому что она обращает действие getc.
int ungetc ( int C, FILE *sream) (функция)
Если С - EOF, ungetc не делает ничего и только возвращает EOF. Это позволяет Вам вызывть ungetc с возвращаемым значением getc без проверки ошибки из getc.
Символ, который Вы помещаете обратно, не обязательно тот который фактически читался из потока. Т. е. читать какой-нибудь символ из потока перед его обратным чтением не обязательно! Но это - странный способ писать программу; обычно ungetc используется только, чтобы читить обратно символ, который только что читался из того же самого потока.
Библиотека GNU С поддерживает только один символ pushback другими словами, нельзя вызвать ungetc дважды без ввода между вызовами. Другие системы могут позволять Вам, помещать обратно много символов; тогда чтение из потока восстанавливает символы в обратном порядке, от того как они были помещены.
Выталкивание обратных символов не изменяет файл; и воздействует только на внутреннюю буферизацию потока. Если вызывается позиционирующая файл функция (типа fseek или rewind; см. раздел 7.15 [Позиционирование файла]), все отложенные помещаемые-обратно символы отбрасываются.
Обратное чтение символа в поток, который находится в конце файла, стирает индикатор конца файла для потока. После того, как Вы читаете тот символ, пробуя читать снова Вы столкнетесь с концом файла.
Вот пример, показывающий использование getc и ungetc, чтобы перескочить символы промежутков. Когда эта функция достигает символа не-промежутка, она читает обратно этот символ, и он будет замечен снова на следующей операции чтения из потока.
#include <stdio.h>
#include <ctype.h>
void skip_whitespace (FILE * stream)
{
int с;
do
/* Нет нужды проверять EOF, потому что это - не isspace, а ungetc
игнорирует EOF. */
c = getc (stream);
while (isspace (c));
ungetc (c, stream);
}
Функции, описанные в этом разделе (printf и др.) обеспечивают, удобный способ выполнять форматированный вывод. Вы вызываете printf со строкой формата или строкой шаблона, которая определяет, как форматировать значения остающихся аргументов.
Если ваша программа не фильтр, который специально выполняет строчно- или символьно- ориентированную обработку, использование printf, или одной из других зависимых функций, описанных в этом разделе - обычно самый простой и наиболее краткий способ выполнить вывод. Эти функции особенно полезны для печати сообщений ошибок, таблицы данных, и т.п..
Функция printf может использоваться, чтобы печатать любое число аргументов. Аргумент строки шаблона, который Вы обеспечиваете в обращении, обеспечивает информацию не только относительно числа дополнительных аргументов, но также относительно их типов и какой стиль должен использоваться для печати.
Обычные символы в строке шаблона просто записываются в выходной поток как есть, в то время как спецификации преобразования, представленные символом `%' в шаблоне заставляют последующие аргументы форматироваться при записи в выходной поток. Например:
int pct = 37;
char filename[] = "foo.txt";
printf ("Processing of `%s' is %d%% finished.\nPlease be
patient.\n", filename, pct);
Processing of `foo.txt' is 37% finished. Please be patient.
Имеются также преобразования для печати целочисленного аргумента как значения без знака в восьмеричной, десятичной, или шестнадцатеричной системе счисления ("%o", "%u", или "%x", соответственно); или как символьного значения ("%c").
Числа с плавающей запятой могут быть напечатаны в нормальной, с фиксированной запятой записи, используя "%f" преобразование или в экспоненциальном представлении чисел, используя "%e" преобразование. "%g" преобразование использует или "%e" или формат "%f", в зависимости от того что более подходит для заданного числа.
Вы можете управлять форматированием более точно, написав модификаторы между "%" и символом, который указывает какое преобразование применить. Они немного изменяют обычное поведение преобразования. Например, большинство спецификаций преобразования разрешает Вам определять минимальную ширину поля и флаг, указывающий, хотите ли Вы чтобы результат выравнивался по правому или по левому краю поля.
Специфические флаги и модификаторы, которые разрешаются и их интерпретация, изменяются в зависимости от преобразований. Они все описаны более подробно в следующих разделах. Не волнуйтесь, если это все кажется чрезмерно сложным; Вы можете почти всегда получать приемлемый вывод без использования какого-нибудь из модификаторов вообще. Модификаторы обычно используются, чтобы делать просмотр вывода в таблицах.
Этот раздел обеспечивает подробности относительно точного синтаксиса спецификаций преобразования, которые могут появляться в printf строке шаблона.
Символы в строке шаблона, которые - не часть спецификации преобразования, печатаются как есть в выходной поток. Последовательности мультисимволов (см. Главу 18 [Расширенные символы]) разрешены в строке шаблона.
Спецификации преобразования в строке шаблона имеют общую форму:
% флаги ширины [. точность] тип преобразования
Например, в спецификаторе преобразования "%-10.8ld", "-" является флагом, "10" определяет ширину поля, точность - "8", символ "l" является модификатором типа, и "d" определяет стиль преобразования. (Этот специфический спецификатор типа говорит, что печатается long int аргумент в десятичной записи, с минимумом 8 цифр, выровненных по левому краю в поле по крайней мере шириной 10 символов.)
Более подробно, спецификации преобразования вывода состоят из начального символа `%', сопровождаемого последовательностью:
Вывод целого числа как десятичного числа со знаком. См. Раздел 7.9.4 [Целочисленные Форматы].
'%d' и '%i' являются синонимами для printf, но отличаются при использовании scanf для ввода (см. Раздел 7.11.3 [Таблица форматов ввода]).
Печатает целое число как восьмеричное число без знака. См. Раздел 7.9.4 [Целочисленные форматы].
Печатает целое число как десятичное число без знака. См. Раздел 7.9.4 [Целочисленные форматы].
Печатает целое число как десятичное число без знака, принимая как тип size_t. Детали см. в Разделе 7.9.4 [Целочисленные Форматы]. Этот формат является расширением GNU.
Печатают целое число как шестнадцатеричное без знака. '%x' использует символы нижнего регистра а '%X' - верхнего регистра. См. Раздел 7.9.4 [Целочисленные форматы].
Печатает число с плавающей запятой в нормальной записи (с фиксированной запятой). См. подробности в Разделе 7.9.5 [Форматы с плавающей запятой].
Печатают число с плавающей запятой в экспоненциальном представлении чисел. '%e' использует символы нижнего регистра, а '%E' - верхнего регистра.
Выводят число с плавающей запятой либо в нормальном, либо в экспоненциальном представлении. '%g' использует символы нижнего регистра, а '%G' - верхнего регистра.
Печатает одиночный символ. См. Раздел 7.9.6 [Другие форматы Вывода].
Печатает строку. См. Раздел 7.9.6 [Другие форматы Вывода].
Выводит значение указателя. См. Раздел 7.9.6 [Другие форматы Вывода].
Содержит число уже напечатанных символов. См. Раздел 7.9.6 [Другие Форматы Вывода]. Обратите внимание, что эта спецификация формата никогда не производит никакого вывода.
Печатает строку, соответствующую значению errno. (Этот формат формат является расширением GNU.) См. Раздел 7.9.6 [Другие Форматы Вывода].
Печатает символ `%'. См. Раздел 7.9.6 [Другие Форматы Вывода].
Если синтаксис спецификации формата вывода является недопустимым, то результат непредсказуем. Если не достаточно аргументов функции, чтобы обеспечить значения для всех спецификаций преобразования в строке шаблона, или если аргументы неправильных типов, результаты непредсказуемы. Если Вы обеспечиваете большее количество аргументов чем используется в спецификации формата, дополнительные аргументы, просто игнорируются; это иногда полезно.
Этот раздел описывает опции для '%d', '%i', '%o', '%u', '%x', '%X', и '%Z' спецификаций преобразования. Эти преобразования печата ют целых числа в различных форматах. Форматы '%d' и '%i' печатают целочисленный аргумент как деся тичное число со знаком; в то время как '%o', '%u', и '%x' печатают аргумент как восьмеричное, десятичное, или шестнадцатеричное без знака соответственно. Формат '%X' - точно то же что и '%x' за исключением того, что она использует символы 'ABCDEF' в качестве цифр вместо 'abcdef'. '%Z' подобна '%u' но принимает аргумент типа size_t.
Имеют значение следующие флаги:
Выравнивание слева результата в поле вывода (вместо нор мального выравнивания справа).
Для знаковых форматов '%d' и '%i', печатает знак '+', если значение положительно.
Для знаковых форматов '%d' и '%i', если результат не начи нается со знака '+' или знака '-', то ставит перед ним пробел. '*' Для формата '%o' ставит '0' первой цифрой, как будто, увеличивая точность. Не делает ничего полезного для форматов '%d', '%i', или '%u'. Использование этого флага производит вывод, который может анализироваться функциями strtoul (см. Раздел 14.7.1 [Синтаксический анализ Целых чисел]) и scanf с форматом '%i' (см. Раздел 7.11.4 [Числовые форматы ввода]).
Дополняют поле нулями вместо пробелов. Нули помещаются пос ле какой-нибудь индикации относительно знака. Этот флаг игнорируется, если указан флаг '-' , или если указана точность.
Без модификатора типа, соответствующий аргумент обрабатывается как int (для знаковых преобразований '%i' и '%d') или int без знака (для преобразований без знака '%o', '%u', '%x', и '%X'). Заметьте, что т. к. printf и ее производные функции, любой аргумент типа char и short автоматически приводится к типу int аргументами, заданными по умолчанию. Для аргументов других целочисленных типов, Вы можете использовать следующие модификаторы:
Определяет, что аргумент - short int или short unsigned int.
Определяет, что аргумент - long int или long unsigned int
Определяет, что аргумент - long long int. (Этот тип яв ляется расширением, обеспечиваемым компилятором GNU С. На системах, которые не поддерживают сверхдлинные целые числа, это - тоже что long int.)
Вот пример использования строки шаблона:
'| %5d| %-5d| %+5d| %+-5d| %5d| %05d| %5.0d| %5.2d| %d|\n '
| 0 | 0 | + 0 | + 0 | 0 | 00000| | 00 | 0 |
| 1 | 1 | + 1 | + 1 | 1 | 00001| 1 | 01 | 1 |
| -1 | -1 | -1 | -1 | -1 | -0001| -1 | -01 | -1 |
|100000|100000|+ 100000|100000|100000|100000|100000|100000|...
Вот еще несколько примеров, показывающих, как выводятся беззнаковые целые под различными опциями формата, используя строку шаблона:
'| %5u | %5o | %5x | %5X | %*5o | %*5x | %*5X | %*10.8x | \n'
| 0 | 0 | 0 | 0 | 0 | 0x0 | 0X0 |0x00000000|
| 1 | 1 | 1 | 1 | 01 | 0x1 | 0X1 |0x00000001|
|100000|303240|186a0|186A0|0303240|0x186a0|0X186A0|0x000186a0|
Этот раздел содержит спецификации форматов вывода чисел с плаваю щей запятой: '%f', '%e', '%E', '%g', и '%G'. Формат '%f' печатает ар гумент в формате с фиксированной запятой, выводя его на экран в виде [-] ddd.ddd, где число цифр после десятичной точки определяется точ ностью, которую Вы указали.
Формат '%e' печатает аргумент в экспоненциальном представлении, выводя его на экран в виде [-] d.ddde [+ | -] dd. Число цифр после десятичной точки также определяется точностью. Экспонента всегда содержит по крайней мере две цифры. На этот формат похож '%E', но экспонента отмечена символом ' E ' вместо ' e '.
Форматы '%g' и '%G' печатают аргумент в стиле '%e' и '%E' соответственно, если экспонента меньше чем -4 или больше либо равна точности; в противном случае они используют стиль формата '%f'. Конечные нули из дробной части результата удаляются, а символ десятичной точки появляется только, если он сопровождается цифрой.
Чтобы изменить поведение функции, могут применяться следующие флаги:
Выравнивание слева результата в поле вывода. Обычно результат выравнивается справа.
Всегда выводится знак 'плюс' или 'минус'.
Если результат не начинается со знака 'плюс' или 'минус', ставит перед ним пробел.
Определяет, что результат должен всегда включать десятичную точку, даже если за ней не следует никаких цифр. Для форматов '%g' и '%G', конечные нули после десятичной точки удаляться не будут.
Дополняет поле нулями вместо пробелов; нули помещаются после знака.
Этот флаг игнорируется, если указан флаг '-'.
Точность определяет, сколько цифр следуют за символом десятичной точки для форматов '%f','%e', и '%E'. Точность, заданная по умолчанию для этих форматов - 6. Если она явно задана как 0, то символ десятичной точки подавляется. Для форматов '%g' и '%G', точность определяет сколько значащих цифр печатать. Значащие цифры это первая цифра перед десятичной точкой, и все цифры после нее. Если для '%g' или '%G' точность - 0 или не задана, то она обрабатывается как если бы была 1. Если напечатанное значение не может быть выражено точно заданным количеством цифр, то значение округляется до ближайшего подходящего значения.
Без модификатора типа, форматы с плавающей запятой используют аргумент двойного типа. (По умолчанию любой аргумент типа float автоматически преобразуется в double.) Поддерживаются следующие модификаторы типов:
как при выводе используются различные форматы чисел с плавающей запятой. Все числа были напечатаны, используя следующий шаблон строки:
'|%12.4f|%12.4e|%12.4g|\n'
| 0.0000| 0.0000e+00| 0|
| 1.0000| 1.0000e+00| 1|
| -1.0000| -1.0000e+00| -1|
| 100.0000| 1.0000e+02| 100|
| 1000.0000| 1.0000e+03| 1000|
| 10000.0000| 1.0000e+04| 1e+04|
| 12345.0000| 1.2345e+04| 1.234e+04|
| 100000.0000| 1.0000e+05| 1e+05|
| 123456.0000| 1.2346e+05| 1.234e+05|
Этот раздел описывает различные форматы, используемые printf.
Формат '%c' печатает одиночный символ. Аргумент типа int сначала преобразовывается в unsigned char. Может использоваться флаг '-' для задания выравнивания слева в поле вывода, но точность или модификатор типа не могут быть определены. Например:
printf ('%c%c%c%c%c', 'h', 'e', 'l', 'l', 'o');
`hello'.
printf ('%3s%-6s', 'no', 'where');
`nowhere'.
Если Вы случайно передаете в качестве аргумента для формата '%s' пустой указатель преобразования, библиотека GNU выведет '(null)'. Мы думаем, что это более полезно чем сообщение об ошибке.
fprintf (stderr, 'can't open `%s': %m\n', filename);
fprintf (stderr, 'can't open `%s': %s\n', filename, strerror (errno));
Формат '%p' печатает значение указателя. Соответствующий аргумент должен иметь тип void*. Практически, Вы можете использовать любой тип указателя.
В системе GNU, непустые указатели печатаются как integers unsigned, как при использовании формата '%#x'. Пустые указатели печатаются как '(nil)'. (В других системах указатели могут печататься по-другому.)
Например:
printf ('%p', 'testing');
Вы можете добавить флаг '-' к формату '%p', чтобы обеспечить выравнивание слева, но не должны определяться никакие другие флаги, точность, или модификаторы типа.
Формат '%n' - отличается от всех других форматов вывода. Он использует аргумент, который должен быть указателем на int, но вместо того, чтобы печатать что-нибудь, он содержит число уже напечатанных символов. Модификаторы типа 'h' и 'l' задают, что указывается аргумент типа short int* или long int * вместо int *, но не позволяется указывать никакие флаги, ширину поля, или точность.
Например,
int nchar; printf ('%d %s%n\n', 3, 'bears', &nchar);
3 bears
Формат '%%' выводит символ `%'. Этот формат не использует аргумент.
Этот раздел описывает, как вызвать printf и относящиеся к ней функции. Прототипы для этих функций находятся в файле 'stdio.h'. Т. к. эти функции принимают переменное число аргументов, Вы должны объявить прототипы для них перед использованием. Конечно, самый простой способ удостовериться, что Ваши прототипы все правильные, это включить 'stdio.h'.
Функция printf выводит указываемые аргументы под управлением шаблона строки TEMPLATE в поток stdout. Она возвращает число напечатанных символов, или отрицательное значение при ошибке вывода.
Эта функция - аналог printf, за исключением того, что вывод записывается в указанный поток вместо stdout.
Она подобна printf, за исключением того, что вывод сохраняется в символьном массиве s вместо записи в поток. Пустой символ записывается в конец строки.
Функция sprintf возвращает число символов, содержащихся в массиве s, исключая пустой символ завершения.
Поведение этой функции неопределено, если копирование происходит между пересекающимися объектами. Например, если s также является аргументом, который выводится под управлением формата '%s'. См. Раздел 5.4 [Копирование и Конкатенация].
Предупреждение: функция sprintf может быть опасна, т. к. она может потенциально выводить большее количество символов чем размер, зарезервированный для строки s. Не забудьте, что ширина поля, заданная в спецификации формата - только минимальное значение.
Чтобы избежать этой проблемы, Вы можете использовать snprintf или asprintf, описанные ниже.
Функция snprintf подобна sprintf, за исключением того, что аргумент размера определяет максимальное число выводимых символов. Конечный пустой символ подпадает под это ограничение
Возвращаемое значение - число сохраненных символов, не включая пустой символ завершения. Если это значение равняется size-1, то в s недостаточно места для всего вывода. Вы должны пробовать снова с большей строкой вывода. Вот пример такого кода:
/* Выдаем сообщение, описывающее значение переменной
с именем NAME и значением VALUE */ char * make_message
(char *name, char *value) {
/* Предположим, что нам понадобится не больше чем 100
символов. */ int size = 100; char *buffer = (char *)
xmalloc (size);
while (1) {
/* Попытаемся напечатать в отведенном пространстве. */
int nchars = snprintf (buffer, size, 'value of %s is
%s', name, value);
/* If that worked, return the string. */
if (nchars < size) return buffer;
/* Иначе попытаемся еще раз с удвоенным количеством
символов */ size *= 2; buffer = (char *) xrealloc
(size, buffer);
}
}
На деле, часто проще использовать asprintf, см. ниже.
Функции в этом разделе форматируют вывод и помещают результаты в динамически размещенную память.
Эта функция похожа на sprintf, за исключением того, что она динамически распределяет строку для вывода (как malloc; см. Раздел 3.3 [Беспрепятственное Резервирование], вместо того, чтобы помещать вывод в буфер, определяемый заранее. Аргумент ptr должен быть адресом объекта char*, и asprintf сохраняет в нем указатель на размещенную строку.
char * make_message (char *name, char *value) {
char *result; asprintf (&result, 'value of %s is %s', name,
value); return result;
}
template,...)
Эта функция подобна asprintf, за исключением того, что она использует obstack, чтобы зарезервировать пространство в памяти. См. Раздел 3.4 [Obstack].
Функции vprintf и подобные позволяют Вам определять ваши собственные различные printf-подобные функции, которые используют ту же самую внутреннюю организацию как и встроенные форматирующие функции вывода.
Наиболее естественный способ определять такие функции состоит в том, чтобы использовать конструкцию типа 'Вызвать printf и передать ему этот шаблон плюс все мои аргументы пропуская первые пять.' Но не имеется никакого способа сделать это на C, и было бы трудно это сделать, потому что на уровне Языка C не имеется никакого способа указать сколько аргументов получает ваша функция.
Так как тот метод невозможен, мы поставляем дополнительные функции типа vprintf, которые позволяет Вам передавать va_list, чтобы описать 'все мои аргументы после первых пяти.'
Перед вызовом vprintf или других функций, перечисленных в этом разделе, Вы должны вызвать va_start (см. Раздел A. 2 [Variadic Функции]) чтобы установить указатель на переменные аргументы. После этого Вы можете вызывать va_arg, чтобы выбрать аргументы, которые Вы хотели обработать.
Если ваш vуказатель a_list указывает на аргументы вашего выбора, Вы можете вызвать vprintf. Этот аргумент и все последующие аргументы, которые были переданы вашей функции, используются vprintf наряду с шаблоном, который Вы определили отдельно.
В некоторых других системах, указатель va_list может стать недопустимым после обращения к vprintf, так что Вы не должны использовать va_arg после того, как Вы вызываете vprintf. Вместо этого, Вы должны вызвать va_end, чтобы отменить указатель. Затем Вы можете безопасно вызывать va_start для другой переменной указателя и начинать выбирать аргументы снова через этот указатель. Вызов vprintf не разрушает список параметров вашей функции.
GNU C не имеет таких ограничений. Вы можете продолжать выбирать аргументы из списка va_list после выполнения через vprintf, тогда va_end - пустая команда. (Примечание, последующие обращения va_arg выберут те же самые аргументы, как и те, что предварительно использованы vprintf.)
Прототипы для этих функций объявлены в 'stdio.h'.
Эта функция подобна printf за исключением того, что ей, вместо переменной, содержащей число аргументов, необходимо передавать указатель на список параметров.
Эта функция - эквивалент fprintf с переменным списком параметров, заданным непосредственно как и для vprintf.
Эта функция - эквивалент sprintf с переменным списком параметров, заданным непосредственно как в vprintf.
Это функция - эквивалент snprintf с переменным списком параметров, заданным непосредственно как в vprintf.
Функция vasprintf - эквивалент asprintf с переменным списком параметров, заданным непосредственно как и для vprintf.
Функция obstack_vprintf - эквивалент obstack_printf с переменным списком параметров, заданным непосредственно как для vprintf.
Ниже приводится пример, показывающий, как Вы могли бы использовать vfprintf. Это - функция, которая выводит сообщения об ошибках в поток stderr, вместе с префиксом, указывающим имя программы (см. Раздел 2.3 [Сообщения об ошибках], описание program_invocation_short_name).
#include <stdio.h>
#include <stdarg.h>
void
eprintf (const char *template, ...)
{
va_list ap;
extern char *program_invocation_short_name;
fprintf (stderr, '%s: ', program_invocation_short_name);
va_start (ap, count);
vfprintf (stderr, template, ap);
va_end (ap);
}
eprintf ('file `%s' does not exist\n', filename);
Вы можете использовать функцию parse_printf_format, для получения информации относительно числа и типов аргументов, которые ожидаются данной строкой шаблона. Эта функция вызывает интерпретаторы, которые обеспечивают интерфейс в printf во избежание передачи недопустимых аргументов.
Все символы, описанные в этом разделе объявлены в файле заголовков 'printf.h'.
Эта функция возвращает информацию относительно числа и типов аргументов, ожидаемых printf в строке шаблонов. Информация сохраняется в массиве argtypes; каждый элемент этого массива описывает один аргумент. Эта информация предоставляется в виде различных 'PA_' макрокоманд, которые перечисляются ниже.
Аргумент n определяет число элементов в массиве argtypes. Это наибольшее число элементов, которые parse_printf_format пробует написать.
Parse_printf_format возвращает общее число аргументов, требуемых шаблоном. Если это число больше n, то возвращаемая информация, описывает только первые n аргументов. Если Вы хотите получить информацию относительно большего, чем n, числа аргументов, зарезервируйте больший массив и вызовете parse_printf_format снова.
Типы аргумента закодированы как комбинация базисного типа и битов флага модификатора.
Эта макрокоманда - маска для битов флага модификатора типа. Вы можете написать выражение (argtypes [i] & PA_FLAG_MASK) чтобы извлечь только биты флага для аргумента, или (argtypes [i] & ~PA_FLAG_MASK) чтобы извлечь только базисный код типа.
Имеются символические константы, которые представляют базисные типы; они устанавливаются для значений integer.
PA_INT Определяет, что исходный тип - int.
PA_CHAR Определяет, что исходный тип - int, приведеннное к char.
PA_STRING Определяет, что исходный тип - char *, строка с нулевым
символом в конце.
PA_POINTER Определяет, что исходный тип - void *, произвольный
указатель.
PA_FLOAT Определяет, что исходный тип с плавающей точкой.
PA_DOUBLE Определяет, что исходный тип - double.
PA_LAST Вы можете определять дополнительные исходные типы для ваших
собственных программ как смещения из PA_LAST.
#define PA_FOO PA_LAST
#define PA_BAR (PA_LAST + 1)
Если этот бит устанавливается, это указывает, что закодированный тип - указатель на исходный тип, а не непосредственное значение.
Например, 'PA_INT | PA_FLAG_PTR' представляет тип `int *'.
Если этот бит устанавливается, это указывает, что исходный тип изменяется как short. (Соответствует модификатору типа 'h'.)
Если этот бит устанавливается, это указывает, что исходный тип изменяется как long. (Соответствует модификатору типа 'l'.)
Если этот бит устанавливается, это указывает, что исходный тип изменяется как long long.
Это - синоним для PA_FLAG_LONG_LONG, используемого обычно с исходным типом PA_DOUBLE для обозначения типа long double.
/* Проверка, является ли NARGS, определяющий объекты вектора
ARGS формату строки FORMAT:
если да, возвращает 1.
в противном случае возвращает 0 после вывода сообщения об ошибке */
int
validate_args (char *format, int nargs, OBJECT *args)
{
int *argtypes;
int nwanted;
/* Получить информацию об аргументах.
Каждый спецификатор формата должен быть длиной по крайней мере
в два символа, поэтому не может быть спецификаторов длиной
длиной больше половины длины строки.
*/
argtypes = (int *) alloca (strlen (format) / 2 * sizeof (int));
nwanted = parse_printf_format (string, nelts, argtypes);
/* Проверим количество аргументов */
if (nwanted > nargs)
{
error ('too few arguments (at least %d required)', nwanted);
return 0;
}
/* Проверим тип, требуемый для каждого аргумента,
и соответствие ему данного аргумента. */
for (i = 0; i < nwanted; i++)
{
int wanted;
if (argtypes[i] & PA_FLAG_PTR)
wanted = STRUCTURE;
else
switch (argtypes[i] & ~PA_FLAG_MASK)
{
case PA_INT:
case PA_FLOAT:
case PA_DOUBLE:
wanted = NUMBER;
break;
case PA_CHAR:
wanted = CHAR;
break;
case PA_STRING:
wanted = STRING;
break;
case PA_POINTER:
wanted = STRUCTURE;
break;
}
if (TYPE (args[i]) != wanted)
{
error ('type mismatch for arg number %d', i);
return 0;
}
}
return 1;
}
Библиотека GNU C позволяет Вам определять ваши собственные спецификаторы преобразования для строк шаблона printf, т.е. научить printf выводить важные структуры данных вашей программы так, как Вам этого хочется.
Это можно сделать, указав формат преобразования с помощью функции register_printf_function; см. Раздел 7.10.1 [Указание Новых Форматов Вывода]. Один из аргументов, которые Вы передаете этой функции указатель на функцию обработчика, которая производит фактический вывод; за более подробной информацией о написании этой функции обращайтесь к Разделу 7.10.3 [Определение Обработчика Вывода].
Вы можете также установить функцию, которая возвращает информацию относительно числа и типа аргументов, ожидаемых спецификатором формата преобразования. См. Раздел 7.9.10 [Синтаксический анализ Строки Шаблона], для получения дополнительной информации об этом.
Средства этого раздела объявлены в файле 'printf.h'.
Примечание о Переносимости: возможность изменения синтаксиса printf строк шаблона - расширение GNU. Стандарт ANSI C не имеет ничего подобного.
Функция для регистрирования новых преобразований вывода register_printf_function, объявлена в `printf.h'.
Эта функция определяет символ спецификатора преобразования SPEC.
Так, если SPEC равен 'q', то определяется модификатор '%q'.
HANDLER_FUNCTION - функция, вызываемая printf, когда это модификатор появляется в строке шаблона. См. Раздел 7.10.3 [Определение Обработчика Вывода], для уточнения информации относительно того, как определить функцию в качестве этого аргумента. Если Вы задаете пустой указатель, существующая функция обработчика для спецификаций удаляется.
Arginfo_function - функция, вызываемая parse_printf_format, когда это преобразование появляется в строке шаблона. См. Раздел 7.9.10 [Синтаксический анализ Строки Шаблона]. Обычно Вы устанавливаете обе функции обработки вывода одновременно, но если Вы никогда не обращаетесь к parse_printf_format, Вы не должны определять функцию arginfo_function.
Возвращаемое значение - 0 в случае успеха, и -1 при сбое (который происходит, если спецификации находятся вне диапазона).
Вы можете переопределять форматы стандартного вывода, но это возможно не лучшая идея из-за потенциального путаницы. Если Вы это сделаете, могут пострадать библиотечные подпрограммы, написанные другими людьми.
Если Вы определяете какое-либо значение для '%q',то что произойдет, если шаблон содержит '%+23q' или '%-#q'? Чтобы реализовать обработку этого, обработчик должен быть способен получить ключи, определенные в шаблоне.
Оба аргумента функции register_printf_function - HANDLER_FUNCTION и ARGINFO_FUNCTION получает в качестве аргумента типа struct printf_info, который содержит информацию относительно ключей, появляющихся в образце спецификатора формата вывода. Этот тип данных объявлен в заглавном файле 'printf.h'.
Эта структура используется для передачи информации о ключах, появляющихся в образце спецификатора формата вывода в printf строке шаблона в обработчик и функции arginfo для их спецификатора. Она содержит следующие элементы:
Эта переменная содержит задаваемую точность. Значение -1, если никакая точность не была определена. Если, точность была задана как '*', структура printf_info, переданная в функцию обработчика, содержит фактическое значение, взятое из списка параметров. Но структура, переданная в функция arginfo содержит значение INT_MIN, так как фактическое значение не известно.
Эта переменная содержит задаваемую минимальную ширину поля вывода. Значение 0, если ширина не была определена. Если, ширина поля была задана как '*', структура printf_info, переданная в функцию обработчика, содержит фактическое значение, взятое из списка параметров. Но структура, переданная в функция arginfo содержит значение INT_MIN, так как фактическое значение не известно.
Эта переменная содержит заданный символ спецификатора формата вывода. Он содержится в структуре для того, чтобы Вы могли указать одну и ту же функцию обработчика для различных символов, но при этом иметь возможность их различать при вызове функции обработчика.
Это - логическая переменная, которая содержит значение истина, если модификатор типа 'L' был определен.
Это - логическая переменная, которая содержит значение истина, если модификатор типа 'h' был определен.
Это - логическая переменная, которая содержит значение истина, если модификатор типа 'l' был определен.
Это - логическая переменная, которая содержит значение истина, если был определен флаг '#'.
Это - логическая переменная, которая содержит значение истина, если был определен флаг ' '.
Это - логическая переменная, которая содержит значение истина, если был определен флаг '-'.
Это - логическая переменная, которая содержит значение истина, если был определен флаг '+'.
Это - символ, использующийся для дополнения вывода в минимальную ширину поля. Значение - '0' если был определен определен флаг '0' , иначе ' '.
Теперь рассмотрим, как определить функцию обработчика и функции arginfo, которые передаются как аргументы для register_printf_functi on.
Вы должны определить ваши функции обработчика с прототипом следу ющим образом:
int function (FILE *stream, const struct printf_info *info, va_list *ap_pointer)
Аргумент stream, переданный функции обработчика - это поток, в который она должна записать вывод.
Аргумент info - указатель на структуру, которая содержит информацию относительно различных ключей, которые были включены в строку шаблона. Вы не должны изменять эту структуру внутри вашей функции обработчика. См. Раздел 7.10.2 [Опции Спецификатора Преобразования], для описания этой структуры данных.
Аргумент ap_pointer используется для передачи хвоста списка параметров, содержащего значения котторые Ваш обработчик должен напечатать. В отличие от большинства других функций, которым может быть передан явный список параметров, здесь передается указатель на va_list, а не сам va_list. Таким образом, Вы должны обрабатывать аргументы с помощью va_arg(TYPE, * ap_pointer).
( Введение указателя здесь позволяет указать функцию, которая вызывает вашу функцию обработчика, чтобы модифицировать собственную переменную va_list, для обновления информации о параметрах, которые ваш обработчик обрабатывает. См. Раздел A. 2 [Variadic (функция)] 2.)
Ваша функция обработчика должна возвратить значение точно так же как это делает printf: она должна возвратить число символов, которое она написала, или отрицательное значение, чтобы указать ошибку.
Это тип данных, который должна иметь функция обработчика. Если Вы собираетесь использовать parse_printf_format в вашем приложении, то Вы должны также определить функцию, являющуюся параметром arginfo_function для каждого нового формата, который Вы устанавливаете с помощью register_printf_function.
Вот прототип подобной функции:
int function (const struct printf_info *info,size_t n,int *argtypes);
Функция должна возвращать число параметров, которые обрабатывает формат вывода. Кроме того, функция не должна заполнять больше, чем n элементов argtypes массива с информацией относительно типов каждого из этих параметров. Эта информация закодирована с помощью 'PA_' макрокоманд. (Обратите внимание, что это - то же самое что и соглашение о вызовах parse_printf_format.)
Этот тип используется, для описания функций, которые возвращают информацию о числе и типе параметров, используемых спецификатором формата вывода.
Вот пример, показывающий, как определять printf функцию обработчика. Эта программа определяет структуру данных называемую Widget и определяет формат '%M', для печати информации о параметре Widget* включая значение указателя и имя, содержащееся в структуре данных. Формат вывода '%W' поддерживает минимальную ширину поля и опции левого выравнивания, но игнорирует все остальные.
#include <stdio.h>
#include <printf.h>
#include <stdarg.h>
typedef struct
{
char *name;
} Widget;
int
print_widget (FILE *stream, const struct printf_info *info, va_list *app)
{
Widget *w;
char *buffer;
int len;
/* Преобразуем выходную информацию в строку. */
w = va_arg (*app, Widget *);
len = asprintf (&buffer, '<Widget %p: %s>', w, w->name);
if (len == -1)
return -1;
/* Заполняем поле минимальной длины и выводим в поток.*/
len = fprintf (stream, '%*s',
(info->left ? - info->width : info->width),
buffer);
/* Сброс и возврат. */
free (buffer);
return len;
}
int
main (void)
{
/ * Создаем widget, который необходимо напечатать. * /
Widget mywidget;
mywidget.name = 'mywidget';
/ * Теперь печатаем widget. * /
printf ('|%W|\n', &mywidget);
printf ('|%35W|\n', &mywidget);
printf ('|%-35W|\n', &mywidget);
return 0;
}
|<Widget 0xffeffb7c: mywidget>|
| <Widget 0xffeffb7c: mywidget>|
|<Widget 0xffeffb7c: mywidget> |
Функции, описанные в этом разделе (scanf и ей подобные) обеспечивают средства для форматируемого ввода, аналогичного форматируемым средствам вывода. Эти функции обеспечивают механизм для чтения произвольных значений при контроле над строкой формата или строкой шаблона.
Вызов scanf на первый взгляд подобен обращениям к printf, в котором произвольные параметры считываются под управлением строки шаблона. В то время, как синтаксис спецификаций преобразования в шаблоне очень схож, синтаксис для printf, интерпретация шаблона ориентируется больше на ввод свободного формата и простое сопоставление с образцом, а не форматирование устанавливаемого поля. Например, большинство scanf пропускают любое преобразование над каким-нибудь количеством 'пробельных символов' (включая пробел, метки табуляции, и символы перевода строки) во входном файле, и нет никакого понятия точности для числовых входных преобразований которое имеется для соответствующих преобразований вывода. Обычно, непробельные символы в шаблоне, как ожидается, будут точно соответствовать символам во входном потоке, но соответствующая ошибка отличается от входной ошибки в потоке.
Другая отличие между scanf и printf - то, что Вы должны не забыть обеспечивать указатели а не непосредственные значения как необязательные параметры scanf; значения, которые читаются, сохраняются в объектах, на которые указывают указатели. Даже опытные программисты имеют тенденцию забывать это иногда, так если ваша программа получает странные ошибки, которые, кажется, связаны со scanf, Вам следует дважды проверить это.
Когда происходит ошибка несоответствия , scanf немедленно прерывается, оставляя первый символ несоответствия как следующий символ, который нужно читать из потока. Нормальное возвращаемое значение из scanf - число значений, которые были назначены, так что Вы можете использовать это, чтобы определить, случалась ли ошибка соответствия прежде, чем все прочитались ожидаемые значения.
Функция scanf обычно используется для программ вроде считывания содержания таблиц. Ниже приводится функция, которая использует scanf для того, чтобы инициализировать массив элементов double:
void readarray (double *array, int n) {
int i; for (i=0; i<n; i++)
if (scanf (' %lf', &(array[i])) !=
1) invalid_input_error ();
}
Если Вы пытаетесь считывать входную информацию, которая не соответствует ни простому, фиксированному шаблону, то может быть Вам лучше использовать средства типа Flex, чтобы сгенерировать лексический сканер, или Bison, чтобы сгенерировать синтаксический анализатор, а не использовать scanf. Для получения более подробной информации, см. раздел 'Flex' в Flex: Лексический Генератор Ввода и раздел 'Bison' в Справочном описании Bison.
Строка шаблона для scanf это строка, которая содержит обычные многобайтовые символы со спецификациями преобразования, которые начинаются с '%'.
Любой пробельный символ (как определено функцией isspace; см. Раздел 4.1 [Классификация Символов]) в шаблоне заставляет любое число символов промежутка во входном потоке читаться и отбрасываться. Символы промежутка, которые согласованы могут быть не точно те же самые символы промежутка которые появляются в строке шаблона. Например, добавьте ',' к шаблону, чтобы распознать запятую с любым количеством пробелов до и после нее.
Другие символы в строке шаблона, которые не являются частью спецификаций преобразования, должны точно соответствовать символам во входном потоке; если дело обстоит не так, возвращается ошибка несоответствия.
Спецификации преобразования в строке scanf шаблона имеют общую форму:
% FLAGS WIDTH TYPE CONVERSION
Ниже приводится таблица, которая содержит различные спецификации форматов:
Соответствует необязательно целому числу со знаком, которое записано в десятичном виде. См. Раздел 7.11.4 [Входные Форматы Чисел].
Соответствует необязательно целому числу со знаком в любом из форматов, которые Язык C определяет для определения константы integer. См. Раздел 7.11.4 [Числовые Входные Преобразования].
Соответствует integer unsigned, который записан в восьмеричной системе счисления. См. Раздел 7.11.4 [Числовые Входные Форматы].
Соответствует беззнаковому целому, записанному в десятичной системе счисления. См. Раздел 7.11.4 [Числовые Входные Преобразования].
Соответствуют беззнаковому целому, записанному в шестнадцатеричной системе счисления. См. Раздел 7.11.4 [Числовые Входные Преобразования].
Соответствуют необязательному знаковому числу с плавающей запятой. См. Раздел 7.11.4 [Числовые Входные Преобразования].
Соответствует строке, содержащей только символы непромежутка. См. Раздел 7.11.5 [Входные Преобразования Строки].
Соответствует строке символов, которые принадлежат заданному множеству. См. Раздел 7.11.5 [Входные Преобразования Строки].
Соответствует строке из одного или большего количества символов; чтение числа символов управляется максимальной шириной поля, заданной для формата.
Соответствует значению указателя в том же самом определенном реализацией формате, используемом форматом вывода printf '%p'. См. Раздел 7.11.7 [Другие Входные Форматы].
Это преобразование не читает никакие символы; оно записывает число прочитанных символов. См. Раздел 7.11.7 [Другие Входные Преобразования].
Это соответствует символу `%' во входном потоке. См. Раздел 7.11.7 [Другие Входные Преобразования]. Если синтаксис спецификации преобразования является недопустимым, поведение неопределено. Если не достаточно аргументов функции, чтобы обнспечить адреса для всех спецификаций формата в строках шаблона, которые выполняют назначения, или если аргументы имеют неправильные типы, поведение также неопределено. С другой стороны, дополнительные аргументы просто игнорируются.
Этот раздел описывает преобразования scanf для чтения числовых значений.
Формат ввода '%d' соответствует необязательно целому числу со знаком в десятичной системе счисления. Синтаксис - такой же как и для функции strtol (см. Раздел 14.7.1 [Синтаксический анализ Целых чисел] ) со значением 10 для основного аргумента.
Формат ввода '%i' соответствует необязательному целому числу со знаком в любом из форматов, которые Язык C определяет для целой константы. Синтаксис - такой же как для функции strtol (см. Раздел 14.7.1 [Синтаксический анализ Целых чисел] ) со значением 0 для основного аргумента. (Вы можете печатать integer в этом синтаксисе через printf, используя флаг '*' с форматами '%x', '%o', или '%d'. См. Раздел 7.9.4 [Целочисленные Преобразования].)
Например, любая из строк '10', '0xa', или '012' может cчитываться как целая константа при преобразовании '%i'. Каждая из этих строк определяет число с десятичным значением 10.
Форматы ввода '%o', '%u', и '%x' соответствуют беззнаковому целому в восьмеричном, десятичном, и шестнадцатеричном форматах соответственно. Синтаксис - такой же как для функции strtoul (см. Раздел 14.7.1 [Синтаксический анализ Целых чисел] ) с соответствующим значением (8, 10, или 16) для основного аргумента.
Формат '%X' идентичен формату '%x'. Оба они разрешают использовать как цифры или символы верхнего регистра или символы нижнего регистра.
Заданный по умолчанию тип соответствующего аргумента форматов '%d' и '%i' является 'int *', и 'unsigned int *' для других целочисленных форматов. Вы можете использовать следующие модификаторы типа, чтобы задать другие размеры integer:
Для преобразований с плавающей запятой, заданный по умолчанию тип аргумента - float *. (Это отличается от соответствующих преобразований вывода, где заданный по умолчанию тип - double; не забудьте, что аргументы float в printf преобразовываются в double заданными по умолчанию поддержками аргумента, но float * аргументы не преобразуются в double *.) Вы можете задавать другие размеры float, используя следующие модификаторы типа:
Этот раздел описывает преобразования ввода scanf для чтения строковых и символьных значений: '%s', '%[', и '%c'.
Имеется два способа получить ввод от этих преобразований:
Формат '%s' соответствует строке непробельных символов. Оно пропускает и отбрасывает начальные пробельные символы, но останавливается, когда сталкивается с пробельным символом когда уже что-то считано. Он сохраняет пустой символ в конце текста, который считывает. Например, при считывании:
hello, world
Предупреждение: если Вы не задаете ширину поля для '%s', то число символов, ограничено только тем, где появится следующий пробельный символ. Это конечно означает что недопустимый ввод может вызвать ошибку.
Чтобы считывать символы, которые принадлежат произвольному набору по вашему выбору, используйте формат '%['. Вы определяете набор между символом `[' и следующим символом `]', используя синтаксис, используемый в регулярных выражениях. Частные случаи:
`%25[1234567890]'
`%25[][]'
`%25[^ \f\n\r\t\v]'
`%25[a-z]'
Расширение GNU для форматируемого ввода позволяет Вам безопасно считывать строку безо всякого указания максимального размера. При использовании этой возможности, Вы не указываете буфер; а вместо этого, scanf распределяет буфер, достаточно большой, чтобы содержать данные и возвращает Вам его адрес. Чтобы использовать эту возможность, укажите 'а' в качестве флага, например '%as' или '%a[0-9a-z]'.
Аргумент указателя, который Вы обеспечиваете для размещения входной информации, должен иметь тип char **. Функция scanf резервирует буфер и сохраняет адрес там, куда указывает аргумент. Вы должны освободить буфер функцией free, когда Вы больше не нуждаетесь в нем.
Вот пример использования флага 'а' со спецификацией преобразования '%[...]' для чтения 'переменного назначения' в форме 'переменная = значение'.
{
char *variable, *value;
if (2 > scanf ('%a[a-zA-Z0-9] = %a[^\n]\n',
&variable, &value))
{
invalid_input_error ();
return 0;
}
...
}
Этот раздел описывает разнообразные входные форматы.
Формат '%p' используется, для того чтобы считывать значение указателя. Оно распознает тот же самый синтаксис, как и формат вывода '%p' для printf (см. Раздел 7.9.6 [Другие Преобразования Вывода]). Соответствующий параметр должен иметь тип void **; то есть адрес места, где разместить указатель.
Формат '%n' возвращает число прочитанных символов. Соответствующий параметр должен иметь тип int *. Это преобразование работает таким же образом как и формат '%n' для printf; см. примеры в Разделе 7.9.6 [Другие Форматы Вывода].
Формат '%n' - единственный механизм для определения успеха буквального соответствия или преобразования с подавляемыми назначениями. Если '%n' следует за ошибкой несоответствия, scanf возвратится, не успев обработать '%n'. Если Вы поместите -1 в этот параметр перед вызовом scanf, присутствие -1 после вызова scanf указывает, что ошибка произошла перед обработкой '%n'.
В заключение, формат '%%' соответствует символу `%' во входном потоке, без использования параметра. Это преобразование не позволяет определение никаких флагов, ширины поля, или модификаторов типа.
Ниже приводятся описания функций для выполнения форматируемого ввода. Прототипы для этих функций находятся в файле 'stdio.h'.
Функция scanf читает форматируемый ввод из потока stdin под управлением строки шаблона. Необязательные параметры - указатели на места, которые получают возникающие в результате значения.
Возвращаемое значение - обычно число успешных соответствий. Если условие конца файла обнаружено перед любым соответствием (включая соответствие пробельным символам и литеральных символов в шаблоне), то возвращается EOF.
Эта функция - аналог scanf, за исключением того, что ввод осуществляется из вместо stdin указанного потока.
Подобна scanf, за исключением того, что символы берутся из строки s с нулевым символом в конце, а не из потока. Достижение конца строки обрабатывается как условие конца файла.
Поведение этой функции неопределено, если копирование происходит между объектами, которые пересекаются, например, если s задан еще и как аргумент для получения считанной строки под управлением формата '%s'.
Функции vscanf и ей подобные работают так, чтобы Вы могли определять ваши собственные scanf-подобные функции, которые используют ту же самую внутреннюю организацию как встроенные форматируемые функции вывода. См. Раздел 7.9.9 [Вывод Аргументов Переменной].
Примечание о Переносимости: функции, перечисленные в этом разделе являются расширением GNU.
Эта функция похожа на scanf за исключением того, что вместо того, чтобы принимать переменное число аргументов непосредственно, она берет указатель на список параметров - ар типа va_list (см. Раздел A.2 Variadic Функции] ).
Эта функция - эквивалент fscanf с переменным списком параметров, заданным непосредственно как для vscanf.
Этот раздел описывает операции ввода и вывода на блоках данных. Вы можете использовать эти функции для чтения и записи двоичных данных, также как читать и писать текст блоками устанавливаемого размера - а не символами или строками.
Сохранение данных в двоичной форме часто значительно более эффективно чем использование форматируемых функций ввода - вывода. Также, для чисел с плавающей запятой, двоичная форма избегает возможной потери точности в процессе преобразования. С другой стороны, двоичные файлы не могут быть легко исследованы или изменяться, используя много стандартных файловых утилит (вроде текстовых редакторов), и не переносимы между различными реализациями языка, или различными видами компьютеров.
Эти функции объявлены в ' stdio.h '.
Эта функция читает до count объектов размера size в массив. Она возвращает число прочитанных объектов, которое может быть меньше чем count, если происходит ошибка чтения, или достигнут конец файла. Эта функция возвращает значение нуль (и ничего не читает) если или size или count равен нулю.
Если fread достигает конца файла в середине объекта, она возвращает номер прочитанных полностью объектов, и отбрасывает несчитанные до конца.
Эта функция записывает до count объектов из массива данных в указанный поток. Возвращаемое значение - обычно count, если считывание успешно. Любой другое значение указывает какую-либо ошибку, например нехватку памяти.
Многие из функций, описанных в этой главе возвращают значение макрокоманды EOF, указывающей неудачное завершение операции. Когда используется EOF, для сообщения о конце файла или о случайной ошибке, часто лучше использовать функцию feof, чтобы явно проверить конец файла и ferror, чтобы проверить наличие ошибки. Это контрольные индикаторные функции, которые являются частью внутреннего состояния объекта потока, индикаторы устанавливаются если соответствующее условие было обнаружено предыдущей операцией ввода - вывода на этом потоке.
Эти символы объявлены в заглавном файле ' stdio.h '.
Этот макрос имеет целое значение, которое возвращается рядом функций, чтобы указать условие конца файла, или какую-нибудь другую ошибку. В библиотеке GNU, EOF имеет значение -1. В других библиотеках, значением может быть некоторое другое отрицательное число.
Эта функция очищает индикаторы конца файла и ошибки для указанного потока. Позиционирующие файл функции (см. Раздел 7.15 [Позиционирование Файла]) также, очищают индикатор конца файла для потока.
Функция feof возвращает отличное от нуля число, только если установлен индикатор конца файла для потока.
Функция ferror возвращает отличное от нуля число, только если индикатор ошибки для потока установлен, указывая что ошибка произошла на предыдущей операции на потоке.
Система GNU и другие posix-совместимые операционные системы организовывает все файлы как однородные последовательности символов. Однако, некоторые другие системы делают различие между файлами, содержащими текст и файлами, содержащими двоичные данные, и средства ввода и вывода ANSI C предусматривают это различие. Этот раздел сообщает Вам, как написать программы, переносимые на такие системы.
Когда Вы открываете поток, Вы можете определять или текстовый поток или двоичный поток. Вы указываете, что Вы хотите двоичный поток, определяя модификатор 'b' в параметре opentype для fopen; см. Раздел 7.3 [Открытие Потоков]. Без этой опции, fopen открывает файл как текстовый поток.
Текстовые и двоичные потоки имеют различия:
В библиотеке GNU, и на всех POSIX системах, не имеется никакого различия между текстовыми потоками и двоичными потоками. Когда Вы открываете поток, Вы получаете тот же самый вид потока, даже если Вы заказывали двоичный. Этот поток может обрабатывать любое содержание файла, и не имеет ни каких ограничений, которые в отличие от текстовые потоков.
Позиция файла потока описывает, где в файле поток в настоящее время читает или производит запись. Ввод-вывод на потоке продвигает позицию файла через весь файл. В системе GNU, позиция файла представляется как целое число, которое содержит число байтов от начала файла. См. Раздел 6.1.2 [Позиция Файла].
В течение ввода-вывода в обычный дисковый файл, Вы можете менять позицию в файле всякий раз, когда Вы желаете читать или записывать в любую часть файла. Некоторые другие виды файлов также позволяют делать это. Файлы, которые поддерживают изменение позиции файла иногда упоминается как файлы прямого доступа.
Вы можете использовать функции в этом разделе, чтобы исследовать или изменить индикатор позиции файла, связанный с потоком. Символы, перечисленные ниже объявлены в заглавном файле 'stdio.h'.
Эта функция возвращает текущую позицию файла указанного потока.
Эта функция может выдать ошибку, если поток не поддерживает позиционирование файла, или если позиция файла не может представляться как long int, или возможно по другим причинам.
Если происходит ошибка, возвращаемое значение -1.
Функция fseek используется для изменения позиции файла указанного потока. Значение whence должно быть одной из констант SEEK_SET, SEEK_CUR, или SEEK_END, т. е. указывать является ли смещение относительно начала файла, текущей позиции файла, или конца файла, соответственно. Эта функция возвратит нуль, если операция была успешна, и значение, отличное от нуля чтобы указать отказ.
Успешное обращение также очищает индикатор конца файла потока и отбрасывает любые символы, которые были 'помещены обратно' использованием ungetc. Fseek дописывает любой буферизированный вывод перед позиционированием файла, или еще запоминает его, так что он будет записан позже в соответствующем месте файла.
Следующие символические константы определены для использования в качестве аргумента whenceа для fseek. Они также используются функцией lseek (см. Раздел 8.2 [Примитивы ввода - вывода] ) и для указания смещения для блокировок файла (см. Раздел 8.7 [Операции Управления] ).
Это целая константа которая, когда используется как аргумент whence функции fseek и определяет, что смещение указывается относительно начала файла.
Это целая константа которая используется как аргумент whence функции fseek и определяет, что смещение указывается относительно текущей позиции файла.
Это целая константа которая используется как аргумент whence функции fseek и определяет, что смещение указывается относительно конца файла.
Функция rewind позиционирует указанный поток в начало файла. Это эквивалентно вызову fseek на потоке с аргументом смещения 0L и аргументом whence SEEK_SET, за исключением того, что возвращаемое значение отбрасывается, и индикатор ошибки для потока сброшен.
Эти три побочных результата исследования для констант 'SEEK_...' существуют ради совместимости с более старыми BSD системами. Они определены в двух различных файлах: 'fcntl.h' и 'sys/file.h'.
L_SET синоним SEEK_SET.
L_INCR синоним SEEK_CUR.
L_XTND синоним SEEK_END.
В системе GNU, позиция файла - просто символьный счетчик. Вы можете задавать любое значение count как аргумента в fseek и получать надежные результаты для любого файла произвольного доступа. Однако, некоторые ANSI C системы не представляет позиции файла таким образом,.
На некоторых системах, где текстовые потоки отличаются от двоичных потоков невозможно представить позицию файла текстового потока как счетчик символов от начала файла. Например, позиция файла на некоторых системах должна кодировать, и смещение записи внутри файла, и смещение символа внутри записи.
Как следствие, если Вы хотите чтобы ваши программы были переносимы на эти системы, Вы должны соблюдать некоторые правила:
Но даже если Вы соблюдаете эти правила, Вы можете все еще иметь проблемы длинными файлами, т. к. ftell и fseek используют значение int long, для представления позицию файла. Этот тип может не иметь участка памяти, для кодирования всех позиций файла в большом файле.
Так, если Вы хотите поддерживать системы со специфическими кодированием для позиций файла, то лучше использовать функции fgetpos и fsetpos. Эти функции представляют позицию файла, используя тип данных fpos_t, чье внутреннее представление меняется от системы к системе.
Эти символы объявлены в заглавном файле ' stdio.h '.
Это - тип объекта, который может кодировать информацию относительно файловой позиции потока, для использования функциями fgetpos и fsetpos.
В системе GNU, fpos_t эквивалентен off_t или long int. В других системах, он может иметь различное внутреннее представление.
Эта функция сохраняет значение индикатора файловой позиции для указанного потока в указанном объекте fpos_t. Обращение успешно если fgetpos возвращает нуль; иначе она возвращает значение отличное от нуля и сохраняет определенное реализацией положительное значение в errno.
Эта функция устанавливает индикатор файловой позиции для указанного потока в позицию position, которая должна определяться предыдущим обращением к fgetpos на том же самом потоке. Если обращение успешно, fsetpos очищает индикатор конца файла на потоке, отбрасывает любые символы, которые были 'помещены обратно' использованием ungetc, и возвращает значение нуля. Иначе, fsetpos возвращает значение отличное от нуля и сохраняет определенное реализацией положительное значение в errno.
Символы, которые записаны в поток, обычно накапливаются и передаются в файл блоками асинхронно, вместо того, чтобы появляться, как только они выводятся прикладной программой. Аналогично, потоки часто восстанавливают ввод из главной среды в блоках а не по принципу символ-за-символ. Это называется буферизацией.
Если Вы напишете программы, которые делают интерактивный ввод и вывод используя потоки, Вы должны знать, как работает буферизация, когда Вы разрабатываете интерфейс пользователя в вашей программе. Иначе, вывод (типа подсказки) может не появиться, как ожидалось, и т. д.
Этот раздел имеет дело только с управлением передачей символов между потоком и файлом или устройством.
Вы можете обходить средства буферизации потока в целом(вполне), используя ввод и вывод низкого уровня, которые функционируют на описателях файла. См. Главу 8 [ввод - вывод низкого уровня].
Имеются три различных вида cтратегий буферизации:
Использование строчной буферизации для интерактивных устройств подразумевает окончание вывода сообщения с символом перевода строки. Вывод, который не заканчивается на символе перевода строки, может и не быть обнаружен немедленно, так если Вы хотите вывести его немедленно, Вы должны очистить буферизированный вывод функцией fflush, как описано в Разделе 7.17.2 [Очистка буфера].
Буферизация строки - хорошее значение по умолчанию для ввода терминала, т. к. большинство интерактивных программ читают команды, которые являются обычно одиночными строками. Программа должна быть способна выполнять каждую строку сразу же. Буферизированный ввод также согласуется с обычными редактирующими вводом средствами большинства операционных систем, которые работают внутри строки ввода.
Они включают программы, которые читают одиночно - символьные команды (подобно Emacs) и программам, которые делают их собственное редактирование ввода (типа тех что используют readline). Чтобы просто читать символ, не достаточно выключить буферизацию во входном потоке; Вы должны также выключить редактирование ввода, в операционной системе. Это требует изменения режима терминала (см. Раздел 12.4 [Режимы Терминала] ).
Сброс вывода на буферизированном потоке, передает все накопленные символы в файл. Имеются много обстоятельств когда буферизированный вывод на потоке, сбрасывается автоматически:
Если Вы хотите сбросить буферизированный вывод в другой момент, вызывайте fflush, которая объявлен в заглавном файле ' stdio.h '.
Эта функция заставляет любой буферизированный вывод на потоке дописываться в файл. Если поток - нулевой указатель, то буферизированный вывод на всех открытых выходных потоках будет сброшен.
Эти функции возвращают EOF, если происходит ошибка записи, и нуль в другом случае.
Примечание о Совместимости: Некоторые поврежденные в уме операционные системы, как известно, были настолько помешаны на строчно ориентированном вводе, что для сброса строчно буферизированного потока должен быть введен символ перевода строки! К счастью, эта 'удобство', кажется, становится менее распространенным. В системе GNU беспокоиться об этом Вам нет нужды.
После открытия потока (но прежде любой другой операции на нем), Вы можете явно определить какую буферизацию Вы хотите, используя функцию setvbuf.
Средства, перечисленные в этом разделе объявлены в файле 'stdio.h'.
Эта функция используется, чтобы определить, что указанный поток должен иметь заданный режим буферизации, который может быть: _IOFBF (для полной буферизации), _IOLBF (для буферизации строки), или _IONBF (для небуферизованного ввода -вывода).
Если Вы определяете нулевой указатель как параметр buf, то setvbuf, распределяет буфер, непосредственно используя malloc. Этот буфер будет освобожден, когда Вы закроете поток.
Иначе, buf должен быть символьным массивом, который может содержать по крайней мере size символов. Вы не должны трогать пространство для этого массива, пока поток остается открытым и этот массив остается буфером. Использование автоматического массива - не очень хорошая идея, если Вы не закрываете файл перед выходом из блока, который объявляет массив.
В то время как массив остается буфером потоков, функции ввода вывода потока используют буфер для их внутренних целей. Вы не должны пробовать обращаться к значениям в массиве непосредственно, в то время как поток использует его для буферизации.
Функция setvbuf возвращает ноль в случае успеха, или значение отличное от нуля, если значение режима не допустимо или если запрос не мог быть удовлетворен.
Значение этой макрокоманды - константа integer, которая может использоваться как параметр режима для функции setvbuf, чтобы определить, что поток должен быть полностью буферизирован.
Значение этой макрокоманды - константа integer, которая может использоваться как параметр режима для функции setvbuf, чтобы определить, что поток должен быть буферизирован строчно.
Значение этой макрокоманды - константа integer, которая может использоваться как параметр режима для функции setvbuf, чтобы определить, что поток должен быть небуферизован.
Значение этой макрокоманды - константа integer, которую удобно использовать как параметр size для setvbuf. Это значение, как гарантируют, будет по крайней мере 256.
Значение BUFSIZ выбрано в каждой системе таким, чтобы делать ввод - вывод потока наиболее эффективным.
Фактически, Вы можете лучшее значение, чтобы использовать для размера буфера посредством fstat системного вызова: его можно найти в st_blksize поле атрибутов файла. См. Раздел 9.8.1 [Значения Атрибута].
Иногда также используют BUFSIZ как размер распределения буферов, используемых для соответствующих целей, типа строк, используемых, чтобы получить строку ввода через fgets (см. Раздел 7.6 [Символьный Ввод]). Не имеется никакой специфической причины использовать BUFSIZ для этого вместо любого другого integer, за исключением того, что это могло бы привести к выполнению ввода - вывода в кусках эффективного размера.
Если buf - нулевой указатель, эффект этой функции эквивалентен вызову setvbuf с параметром режима _IONBF. Иначе, это эквивалентно вызову setvbuf с buf, и режимом _IOFBF и параметром size - BUFSIZ. Функция setbuf предусмотрена для совместимости со старым кодом; используйте setvbuf во всех новых программах.
Если buf - нулевой указатель, эта функция делает поток небуферизованным. Иначе, это делает поток полностью буферизированным с использованием buf в качестве буфера. Параметр size определяет длину buf.
Эта функция предусмотрена для совместимости со старым BSD кодом. Используйте вместо нее setvbuf.
Эта функция делает поток буферизированным строчно, и распределяет буфер для Вас. Эта функция предусмотрена совместимость со старым BSD кодом. Используйте setvbuf вместо нее.
Библиотека GNU обеспечивает способы определить дополнительные виды потоков, которые не обязательно соответствуют открытому файлу.
Один такой тип потока берет ввод из или пишет вывод в строку. Эти виды потоков используются внутренне, чтобы выполнить функции sprintf и sscanf. Вы можете также создавать такой поток явно, при использовании функций, описанных в Разделе 7.18.1 [Строковые Потоки].
В более общем смысле, Вы можете определять потоки, которые делают ввод -вывод для произвольных объектов, используя функции, обеспеченные вашей программой. Этот протокол обсужден в Разделе 7.18.3 [Заказные Потоки] .
Примечание о Переносимости: средства, описанные в этом разделе специфические для GNU. Другие системы или реализации C могли и не обеспечивать эквивалентные функциональные возможности.
Функции fmemopen и open_memstream делали ввод - вывод в буфер памяти или строку. Эти средства объявлены в 'stdio.h '.
Эта функция открывает поток, который допускает доступ, определенный параметром opentype, и который считывается или записывается в буфер, определенный параметром buf. Этот массив должен быть по крайней мере size байтов длиной.
Если Вы определяете нулевой указатель как параметр buf, fmemopen динамически распределяет (как с malloc; см. Раздел 3.3 [Беспрепятственное Распределение]) size байтовый массив. Это действительно полезно только, если Вы собираетесь записывать что-то в буфер и затем читать это обратно, т. к. Вы не имеете никакого способа фактически получить указатель на буфер (для этого, попробуете open_memstream, ниже). Буфер освобождается, когда открывается поток. Параметр opentype - такой же как в fopen (См. Раздел 7.3 [Открытие Потоков]). Если opentype определяет режим конкатенирования, то начальная файловая позиция устанавливается на первый символ пробела в буфере. Иначе начальная файловая позиция - в начале буфера.
Для потока, открытого для чтения, пустые символы (нулевые байты) в буфере не считаются концом файла. Операции чтения возвращают конец файла только когда файловая позиция продвигается за size байт. Так, если Вы хотите читать символы из строки с нулевым символом в конце, Вы должны обеспечить длину строки как аргумент size.
Вот пример использования fmemopen для создания потока для чтения из строки:
#include <stdio.h>
static char buffer[] = 'foobar';
int
main (void)
{
int ch;
FILE *stream;
stream = fmemopen (buffer, strlen (buffer), 'r');
while ((ch = fgetc (stream)) != EOF)
printf ('Got %c\n', ch);
fclose (stream);
return 0;
}
Эта программа производит следующий вывод:
Got f
Got o
Got o
Got b
Got a
Got r
Эта функция открывает поток для записи в буфер. Буфер размещен динамически (как с malloc; см. Раздел 3.3 [Беспрепятственное Резервирование]) и растет по мере необходимости.
Когда поток закрывается с помощью fclose или сбрасывается с помощью fflush, указатели ptr и sizeloc модифицируются, и содержат указатель на буфер и size. Значения, таким образом сохраненные остаются допустимыми только, пока не происходит никакой дальнейший вывод на потоке. Если, Вы выводите еще, Вы должны промыть поток, чтобы сохранить новые значения прежде, чем Вы используете его снова.
Пустой символ записывается в конце буфера. Этот пустой символ не включен в значение size, сохраненное в sizeloc.
Вы можете перемещать файловую позицию потока функцией fseek (см. Раздел 7.15 [Позиционирование Файла]). Перемещение файловой позиции после конца уже записанных данных, заполняет захваченное пространство нулями.
Вот пример использования open_memstream:
#include <stdio.h>
int
main (void)
{
char *bp;
size_t size;
FILE *stream;
stream = open_memstream (&bp, &size);
fprintf (stream, 'hello');
fflush (stream);
printf ('buf = `%s', size = %d\n', bp, size);
fprintf (stream, ', world');
fclose (stream);
printf ('buf = `%s', size = %d\n', bp, size);
return 0;
}
Эта программа производит следующий вывод:
buf = `hello', size = 5
buf = `hello, world', size = 12
Вы можете открывать выходной поток, который помещает данные в obstack. См. Раздел 3.4 [Obstack].
Эта функция открывает поток для записи данных в obstack. Она начинает объект в obstack и увеличивает его, при записывании данных (см. Раздел 3.4.6 [Возрастастающие Объекты]).
Вызов fflush на этом потоке модифицирует текущий размер объекта, в соответствии с количеством данных, которое было записано. После обращения к fflush, Вы можете исследовать объект.
Вы можете перемещать файловую позицию obstack потока функцией fseek (см. Раздел 7.15 [Позиционирование Файла]).
Чтобы сделать объект постоянным, модифицируйте obstack с fflush, и тогда используйте obstack_finish для завершения объекта и получения адреса. Следующая запись в поток, начинает новый объект в obstack.
Но как Вы узнаете, какой длины объект? Вы можете получать длину в байтах, вызывая obstack_object_size (см. Раздел 3.4.8 [Состояние Obstack]), или Вы можете пустым символом завершить объект, примерно так:
obstack_1grow (obstack, 0);
Вот типичная функция, которая использует open_obstack_stream:
char * make_message_string (const char *a, int b)
{
FILE *stream = open_obstack_stream (&message_obstack);
output_task (stream);
fprintf (stream, ': ');
fprintf (stream, a, b);
fprintf (stream, '\n');
fclose (stream);
obstack_1grow (&message_obstack, 0);
return obstack_finish (&message_obstack);
}
Этот раздел описывает, как Вы можете создавать потоки, которые берут ввод из произвольного источника данных или пишут вывод в произвольный сток данных, программируемый Вами. Назовем эти потоки пользовательскими.
Внутри каждого пользовательского потока есть специальный объект называемый cookie. Это - объект, определяемый Вами, который указывает, где берутся или сохраняются данные.
Чтобы реализовать пользовательский поток, Вы должны указать, как выбирать или сохранять данные в заданном месте. Это делается определением функции ловушки для чтения, записи, изменения 'файловой позиции', и закрытия потока. Вся четыре из этих функций будут переданы cookie потока, так чтоони могут сообщать, где брать или сохранять данные. Библиотечные функции не знают что находится внутри cookie, но ваши функции будут знать.
Когда Вы создаете пользовательский поток, Вы должны задать указатель на cookie, а также четыре функции ловушки, содержащиеся в структуре типа struct cookie_io_functions.
Эти средства объявлены в ' stdio.h '.
Это - тип структуры, который содержит функции, которые определяют протокол связи между потоком и cookie. Он имеет следующие элементы:
Это функция, которая читает данные из cookie. Если значение является пустым указателем вместо функции, то операции чтения на потоке всегда возвращает EOF.
Это - функция, которая пишет данные в cookie. Если значение является пустым указателем вместо функции, то данные, записанные в поток отбрасываются.
Это функция, которая выполняет эквивалент позиционирования файла на cookie. Если значение является пустым указателем вместо функции, обращения к fseek на этом потоке, может искать расположения только внутри буфера; любая попытка искать снаружи буфера, возвратит ESPIPE ошибку.
Эта функция выполняет любую соответствующую сброс cookie при закрытии потока. Если значение является пустым указателем вместо функции, то при закрытии потока ничего не делается для закрытия cookie.
Эта функция фактически создает поток для сообщения с cookie используя функции в io_functions аргументе. Opentype аргумент интерпретируется как для fopen; см. Раздел 7.3 [Открытие Потоков]. (Но отметьте что опция 'усечения при открытии' игнорируется.) Новый поток полностью буферизирован.
Функция fopencookie возвращает недавно созданный поток, или пустой указатель в случае ошибки.
Имеется большое количество деталей определения четырех функций ловушки, которые необходимы для пользовательского потока.
Вы должны определить функцию для чтения данных из cookie как:
ssize_t reader (void *cookie, void *buffer, size_t size)
Вы должны определить функцию, для записи данных в cookie как:
ssize_t writer (void *cookie, const void *buffer, size_t size)
Вы должны определить функцию, для выполнения операции позиционирования на cookie как:
int seeker (void *cookie, fpos_t *position, int whence)
Для этой функции, position и whence аргументы интерпретируются как для fgetpos; см. Раздел 7.16 [Переносимое Позиционирование]. В библиотеке GNU, fpos_t эквивалентен off_t или long int, и просто представляет число байтов от начала файла.
После выполнения операции установки, ваша функция должна сохранить возникающую в результате файловую позицию относительно начала файла в position. Ваша функция должна возвратить значение 0 в случае успеха, и -1 в случае ошибки.
Вы должны определить функцию, для операции очистки на cookie, при закрытии потока как:
int cleaner (void *cookie)
Это - тип данных, который должна иметь функция чтения для пользовательского потока. Если Вы объявляете функцию как показано выше, это тип, который она будет иметь.
Тип данных пишущей функции для пользовательского потока.
Тип данных функции инициализации для пользовательского потока.
Тип данных функции close для заказного потока.
Эта глава описывает функции для выполнения операций ввод-вывода низкого уровня с помощью дескрипторов. Эти функции включают примитивы для функций ввода - вывода с более высоким уровнем, описанные в Главе 7 [Ввод - вывод на Потоках], также как функции для выполнения операций управления низкого уровня, для которых не имеется никаких эквивалентов на потоках. Ввод-вывод на уровне потоков более гибок и обычно более удобен; поэтому, программисты используют функции дескрипторного уровня только при необходимости. Вот несколько ситуаций, в которых могут понабиться дескрипторы:
Этот раздел описывает примитивы для открытия и закрытия файлов, используя дескрипторы файла. Функции creat и open объявлены в файле 'fcntl.h', в то время как close объявлена в 'unistd.h'.
Функция open создает и возвращает новый описатель файла для указанного файла. Первоначально, индикатор файловой позиции для файла находится в начале файла. Аргумент mode используется только, когда файл создан.
Аргумент flags управляет тем, как файл будет открыт. Это битовая маска; Вы создаете значение поразрядным ИЛИ соответствующих параметров (используя оператор `|' в C).
Аргумент flags должен включять точно одно из этих значений, для задания режима доступа к файлу:
O_RDONLY Открывает файл для чтения.
O_WRONLY Открывает файл для записи.
O_RDWR Открывает файл, и для чтения и для записи.
O_APPEND Если установлен, то все операции записи запишут данные в
конец файла, расширяя его, независимо от текущей файловой
позиции.
O_CREAT Если установлен, будет создан файл, если он еще не
существует.
O_EXCL Если и O_CREAT и O_EXCL - установлены, то open выдает
ошибку, если заданный файл уже существует.
O_NOCTTY Если filename имя терминала, не делайте его терминалом
управления для процесса. См. Главу 24 [Управление
заданиями], для уточнения информации относительно того,
что означает терминал управления.
O_NONBLOCK Устанавливает режим неблокирования. Эта опция обычно
полезна для специальных файлов типа FIFO (см. Главу 10
[Каналы и FIFO]) и устройств типа терминалов.
Обычно, для этих файлов open блокируется, пока файл не 'готов'.
Если O_NONBLOCK установлен, open возвращается немедленно.
O_NONBLOCK бит также воздействует на чтение и на запись: он
разрешает им возвращаться немедленно с состоянием ошибки,
если не имеется никакого доступного ввода, или если вывод не
может быть записан.
O_TRUNC Если файл существует и открыт для записи, усекает это, до
нулевой длины. Эта опция полезна только для регулярных
файлов, а не специальных файлов типа каталогов или FIFO. Для
получения более подробной информации об этих символических
константах см. Раздел 8.10 [Флаги Состояния Файла].
Файл существует, но не читаем/перезаписываем как запрошено аргументом flags.
И O_CREAT и O_EXCL - установлены, а именованный файл уже существует.
Операция open была прервана сигналом. См. Раздел 21.5 [Прерванные Примитивы] 3.
Аргумент flags задает доступ для записи, а файл - каталог.
Процесс имеет слишком много открытых файлов.
Вся система, или возможно файловая система, которая содержит каталог, не может поддерживать любые дополнительные файлы открытыми в настоящее время. (Эта проблема не может случаться в системе GNU.)
Именованный файл не существует, но O_CREAT не определен.
Каталог или файловая система, которая содержала бы новый файл,не может быть расширена, т. к. там не осталось дискового пространства.
O_NONBLOCK и O_WRONLY установлены в аргументе flags, файл, именованный filename - FIFO (см. Главу 10 [Каналы и FIFO]), и никакой процесс имеет файл открытым для чтения.
Файл постоянно находится в файловой системе только для чтения и любой из O_WRONLY, O_RDWR, O_CREAT, и O_TRUNC установлены в аргументе flags.
Функция open - основной примитив для fopen и freopen функций, которые создают потоки.
Эта функция устаревает. Обращение: creat (filename, mode) эквивалентно: open (filename, O_WRONLY | O_CREAT | O_TRUNC, mode)
Функция закрывает дескриптор файла filedes. Закрытие файла имеет следующие последствия:
Следующие errno условия ошибки определены для этой функции:
TEMP_FAILURE_RETRY (close (desc));
Этот раздел описывает функции для выполнения ввода и вывода с помощьюю дескрипторов файла: read, write, и lseek. Эти функции объявлены в файле ' unistd.h '.
Этот тип данных используется для представления размеров блоков, которые могут быть прочитаны или записаны одиночной операцией. Он подобен size _t, но должен быть знаковым типом.
Функция read читает до size байтов из файла с описателем filedes, сохраняя результаты в буфере. (Это - не обязательно символьная строка и не имеется никакого добавленного пустого символа завершения.)
Возвращаемое значение - число байтов фактически прочитанных. Оно может быть меньше чем size.
Нулевое значение указывает конец файла (за исключением того, если значение аргумента size является также нулем). Это не является ошибкой.
Если read возвращает по крайней мере один символ, не имеется никакого способа, которым Вы можете узнать, был ли конец файла достигнут. Но если Вы достигали конца, следующий read возвратит нуль.
В случае ошибки read возвращает -1. Следующие errno условия ошибки определены для этой функции:
Обычно, когда никакой ввод недоступен, read ждет какого-нибудь ввода. Но если установлен флаг O_NONBLOCK (см. Раздел 8.10 [Флаги Состояния Файла]), read возвращается немедленно не читая никаких данных, и сообщает эту ошибку.
Примечание о Совместимости: Большинство версий BSD UNIX использует различный код ошибки для EWOULDBLOCK. В библиотеке GNU, EWOULDBLOCK - синоним EAGAIN, так что не имеет значения, акое название Вы используете.
На некоторых системах, чтение большого количества данных из символьного специального файла может также выдавать ошибку EAGAIN, если ядро не может найти достаточно памяти для страниц пользователя. Это ограничение для устройств, которые передают с прямым доступом в память, т. е. не включают терминалы, так как они всегда используют отдельные буфера внутри ядра.
Filedes аргумент - не допустимый описатель файла.
Чтение было прервано сигналом, в то время как он ждал ввода.
См. Раздел 21.5 [Прерванные Примитивы]. EIO Для многих устройств, и для файлов на диске, этот код ошибки указывает аппаратную ошибку. EIO также происходит, когда фоновый процесс пробует читать с терминала управления, и нормальное действие остановки процесса, т. е. Посылка сигнала SIGTTIN не работает. Это может случиться, если сигнал блокируется или игнорируется, или т. к. группа процесса - orphaned. См. Главу 24 [Управление заданиями].
Функция read - основной примитив для всех функций, которые читают из потоков, типа fgetc.
Функция write пишет до size байтов из буфера в файл с описателем filedes. Данные в буфере - не обязательно символьная строка и вывод пустого символа подобен любому другому.
Возвращаемое значение - число байтов, фактически записанных. Это - обычно size, но могло бы быть и меньшее количество. В случае ошибки, write возвращает -1. Следующие errno условия ошибки определены для этой функции:
Обычно, write блокируется до завершения операции записи. Но если для файла устанавлен O_NONBLOCK флаг (см. Раздел 8.7 [Операции Управления]), она возвращается немедленно не позводя записи любых данных, и сообщает эту ошибку. Пример ситуации, котаря могла бы вызывать блокировани процесса на выводе, запись в терминальное устройство, которое поддерживает управление потоком данных, где вывод был приостановлен получением символа STOP.
Примечание Совместимости: Большинство версий BSD UNIX использует различный код ошибки для EWOULDBLOCK. В библиотеке GNU, EWOULDBLOCK синоним для EAGAIN, так что не имеет значения, какое название Вы используете.
Аргумент Filedes - не допустимый дескриптор файла.
Размер файла больший чем реализация, может поддерживать.
Операция write была прервана сигналом, в то время как она была блокирована, и ждала завершения. См. Раздел 21.5 [Прерванные Примитивы].
Для многих устройств, и для файлов на диске, этот код ошибки указывает аппаратную ошибку. EIO также происходит, когда фоновый процесс пробует читать с терминала управления, и нормальное действие остановки процесса, посылая сигнал SIGTTIN не работает. Это может случиться, если сигнал блокируется или игнорируется, или т. к. группа процесса - orphaned. См. Главу 24 [Управление заданиями].
переполнение устройства.
Эта ошибка возвращается, когда Вы пробуете писать в канал или в FIFO, который не открыт для чтения процессом. Когда это случается, сигнал SIGPIPE также посылается в процесс; см. Главу 21 [Обработка Сигнала].
nbytes = TEMP_FAILURE_RETRY (write (desc, buffer, count));
Точно как Вы можете устанавливать файловую позицию потока функцией fseek, Вы можете устанавливать файловую позицию дескриптора функцией lseek. Она определяет позицию в файле для следующей операции read или write. См. Раздел 7.15 [Позиционирование Файла], для подробной информации относительно файловой позиции и что это означает.
Для получения текущего значения файловой позиции из описателя, используйте lseek (desc, 0, SEEK_CUR).
Функция lseek используется, чтобы изменить файловую позицию файла с описателем filedes. Аргумент whence определяет, как смещение должно интерпретироваться, таким же образом как в функции fseek, и может быть одной из символических констант SEEK_SET, SEEK_CUR, или SEEK_END.
Определяет, что whence - яисло символов от начала файла.
Определяет, что whence - число символов от текущей файловой позиции. Этот число может быть положительно или отрицательно.
Определяет, что whence - число символов с конца файла. Отрицательное число определяет позицию внутри текущего тела файла; положительное число определяет позицию после текущего конца. Если Вы устанавливаете позицию после текущего конца, и фактически записываете данные, Вы расширяете файл нулями до этой позиции.
Возвращаемое значение lseek - обычно возникающая в результате файловая позиция, измеряемая в байтах от начала файла. Вы можете использовать это средство вместе с SEEK_CUR для чтения текущей файловой позиции.
Вы можете устанавливать файловую позицию после текущего конца файла. Это делает файл больше; lseek никогда не изменяет файл. Но последующий вывод в ту позицию расширит файла.
Если файловая позиция не может быть изменена, или операция выполняется некоторым недопустимым способом, lseek возвращает значение -1. Следующие errno условия ошибки определены для этой функции:
Filedes - не допустимый описатель файла.
Значение аргумента whence не допустимо, или возникающее в результате смещение файла не допустимо.
filedes соответствует каналу или FIFO, который не может быть позиционирован. ( Могут иметься другие виды файлов, которые также не могут быть позиционированы, но в этих случаях поведение не определено.)
Вы можете иметь многократные описатели для того же самого файла, если Вы открываете файл больше чем один раз, или если Вы дублируете описатель с dup. Дескрипторы, которые исходят из отдельных обращений open, имеют независимые файловые позиции; использование lseek на одном дескрипторе не произодит никакого эффекта на другой. Например,
{
int d1, d2;
char buf[4];
d1 = open ('foo', O_RDONLY);
d2 = open ('foo', O_RDONLY);
lseek (d1, 1024, SEEK_SET);
read (d2, buf, 4);
}
Напротив, описатели, сделанные дублированием совместно используют общую файловую позицию с первоначальным описателем, который был дублирован. Изменение файловой позиции одного из дубликатов, включая чтение или запись данных, воздействует на все из них. Таким образом, например,
{
int d1, d2, d3;
char buf1[4], buf2[4];
d1 = open ('foo', O_RDONLY);
d2 = dup (d1);
d3 = dup (d2);
lseek (d3, 1024, SEEK_SET);
read (d1, buf1, 4);
read (d2, buf2, 4);
}
Будет читать четыре символа, начиная с 1024-го символа 'foo', и еще четыре символа, начиная с 1028-го символа.
Это - арифметический тип данных, используемый, чтобы представить размеры файла. В системе GNU, он эквивалентен fpos_t или long int. Эти три синонима константы 'SEEK_...' существуют ради совместимости с более старыми BSD системами. Они определены в двух различных файлах: 'fcntl.h' и 'sys/file.h'.
L_SET синоним для SEEK_SET.
L_INCR синоним SEEK_CUR.
L_XTND синоним SEEK_END.
Определяя дескриптор файла с помощью open, Вы можете создавать поток для него функцией fdopen. Вы можете получить основной описатель файла для существующего потока функцией fileno. Эти функции объявлены в заглавном файле 'stdio.h'.
Функция fdopen возвращает новый поток для описателя файла filedes. Opentype аргумент интерпретируется таким же образом как в функции fopen (см. Раздел 7.3 [Открытие Потоков]), за исключением того, что опция 'b' не разрешается; это оттого, что GNU не делает никакого различия между текстом и двоичными файлами. Также, 'w' и 'w+' не вызывают усечение файла; они воздействуют только при открытии файла, а в этом случае, файл уже открыт. Вы должны удостовериться, что opentype аргумент соответствует фактическому режиму дескриптора файла.
Возвращаемое значение - новый поток. Если поток не может быть создан (например, если режимы для файла, обозначенного дескриптором файла не разрешают доступ, заданный opentype аргументом), взамен возвращается пустой указатель.
Для примера, показывающего использование функции fdopen, см. Раздел 10.1 [Создание Канала].
Эта функция возвращает описатель файла, связанный с указанным потоком. Если обнаружена ошибка (например, если поток не допустим) или если поток, не делает ввод - вывод в файл, fileno возвращает - 1.
Имеются также символические константы, определенные в 'unistd.h' для описателей файла, принадлежащих к стандартным потокам stdin, stdout, и stderr; см. Раздел 7.2 [Стандартные Потоки].
Эта макрокоманда имеет значение 0, которое является дескриптором файла для стандартного ввода.
Эта макрокоманда имеет значение 1, которое является дескриптором файла для стандартного вывода.
Эта макрокоманда имеет значение 2, которое является дескриптором файла для стандартного вывода ошибки.
Вы можете иметь многочисленные дескрипторы файла и потоки (назывем и потоки и дескрипторы 'каналами', для краткости), связанными с одним и тем же файлом, но Вы должны соблюдать осторожность, чтобы избежать путаницы между каналами. Имеются два случая, для рассмотрения: связанные каналы, которые совместно используют одино значение файловой позиции, и независимые каналы которые имеют свои собственные файловые позиции.
Самое лучшее использовать только один канал в вашей программе для фактической передачи данных в любой данный файл, за исключением того, когда весь доступ создан для ввода. Например, если Вы открываете канал (кое-что Вы можете делать только на уровне дескрипторов файла), или делать весь ввод - вывод через дескриптор, или создавать поток с fdopen, и тогда делать весь ввод - вывод через поток.
Каналы, которые исходят из одного открытия, совместно используют ту же самую файловую позицию; мы называем их связанными каналами. Связанные каналы кончаются, когда Вы делаете поток из дескриптора, используя fdopen, и когда Вы получаете описатель из потока с fileno, и когда Вы копируете описатель с dup или dup2. Для файлов, которые не поддерживают, произвольный доступ, типа терминалов и канадов, все каналы действительно связаны. На файлах прямого доступа, все выходные потоки конкатенирующего типа действительно связаны друг с другом.
Если Вы использовали поток для ввода - вывода, и Вы хотите делать ввод - вывод, используя другой канал (или поток или дескриптор) который связан с этим, Вы должны сначала очистить поток, который Вы использовали. См. Раздел 8.5.3 [Очистка Потоков].
Завершение процесса, или выполнение новой программы в процессе, уничтожает все потоки в процессе. Если описатели, связанные с этими потоками сохраняются в других процессах, их файловые позиции станут неопределенными. Чтобы предотвратить это, Вы должны очистить потоки перед их разрушением.
Когда Вы открываете каналы (потоки или описатели) отдельно, каждый канал имеет собственную файловую позицию. Они называются независимыми каналами.
Система обрабатывает каждый канал независимо. В большинстве случаев, это совершенно предсказуемостно и естественно (особенно для ввода): каждый канал может читать или писать последовательно в собственном месте в файле. Однако, если некоторые из каналов - потоки, Вы должны соблюдать предосторожности:
Если Вы выводите по одному каналу в конец файла, это конечно оставит другие независимые каналы, позиционированные где-нибудь перед новым концом. Если Вы хотите, чтобы они вывели в конец, Вы должны установить их файловые позиции в конец файла. (В этом нет нужды, если Вы используете описатель конкатенирующего типа или поток; они всегда выводят в текущий конец файла.)
Двум каналам невозможно иметь отдельные указатели файла для файла, который не поддерживает произвольный доступ. Таким образом, каналы для чтения или записи в такие файлы всегда связаны. Каналы конкатенирующего типа также всегда связаны. Для этих каналов, соблюдайте правила связанных каналов; см. Раздел 8.5.1 [Связанные Каналы].
В системе GNU, Вы можете очистить любой поток функцией fclean:
Очищает указанный поток так, чтобы буфер был пуст. На других системах, Вы можете использовать fflush, чтобы oчистить поток в большинстве случаев. Вы можете пропускать fclean или fflush, если Вы знаете, что поток уже пуст. Поток пуст всякий раз, когда буфер пуст. Например, небуферизованный поток всегда пуст. Входной поток, который находится в конце файла, пуст. Буферизированный строчно поток пуст, когда последний выходной символ был символ перевода строки.
Имеется один случай, в котором сброс потока является невозможным на большинстве систем. Тогда, когда поток делает ввод из файла, не являющегося файлом прямого доступа. Такие потоки обычно читают вперед, и когда файл не произвольного доступа, то нет никакого способа сбросить обратно данные излишка уже прочтитанные. Когда входной поток читается из файла прямого доступа, fflush oчищает поток, но оставляет указатель файла в непредсказуемом месте; Вы должны установить указатель файла перед выполнением любого дальнейшего ввода - вывода. В системе GNU, используя fclean Вы избежите обе эти проблемы.
fflush также делает закрытие выходного потока, так что это допустимый способ очистки выходного потока. В системе GNU, закрытие входного потока вызывает fclean.
Вы не нуждаетесь в чистке потока перед использованием дескриптора для операций управления, типа установки режимов терминала; эти операции не воздействуют на файловую позицию и не зависят от нее. Вы можете использовать любой дескриптор для этих операций, и на все каналы воздействовать одновременно. Однако, текст уже 'выведенный' в поток но все еще буферизируемый потоком будет подчинен новым режимам терминала. Чтобы удостовериться что 'прошлый' вывод подчинен установкам терминала, которые были в действительности во время, сбрасывайте выходные потоки для того терминала перед установкой режимов. См. Раздел 12.4 [Режимы Терминала].
Иногда программа должна принять ввод на нескольких входных каналах всякий раз, когда ввод прибывает. Например, некоторые рабочие станции могут иметь устройства типа планшета отцифровывания, поля функциональной клавиши, или поля набора кода, которые соединены через нормальные асинхронные последовательные интерфейсы; хороший стиль интерфейса пользователя требует, чтобы ответ немедленно воздействовал на любое устройство. Другой пример - программа, которая действует как сервер для нескольких других процессов через каналы или гнезда.
Вы не можете обычно использовать для этой цели read, потому что она блокирует программу до ввода на одном указанном описателе файла; ввод на других каналах не будет иметь действия. Вы могли бы установить режим не блокирования и опрашивать каждый описатель файла по очереди, но это очень неэффективно.
Лучшее решение состоит в том, чтобы использовать функцию выбора. Она блокирует программу до ввода или вывода по заданному набору описателей файла, или по таймеру. Это средство объявлено в заглавном файле 'sys/types.h'.
Наборы описателей файла для функции выбора определены как объекты fd_set. Вот описание типа данных и некоторых макрокоманд для управления этих объектов.
Этот тип данных представляет наборы описателей файла для функции выбора. Это - фактически битовый массив.
Значение этой макрокоманды - максимальное число описателей файла, о которых объект fd_set может содержать информацию. На системах с фиксированным максимальным номером, FD_SETSIZE - по крайней мере это число. На некоторых системах, включая GNU, не имеется никакого абсолютного ограничения числа описателей, но эта макрокоманда все еще имеет постоянное значение, которые управляет числом битов в fd_set.
Эта макрокоманда инициализирует набор наборов описателей файла, как пустое множество.
Эта макрокоманда добавляет filedes к набору описателей файлов.
Эта макрокоманда удаляет filedes из набора дескрипторов файлов.
Эта макрокоманда возвращает значение отличное от нуля (истина), если filedes - элемент набора описателей файлов, и нуль (ложь) иначе.
Вот описание функции выбора непосредственно.
int select (int nfds, fd_set *read_fds, fd_set *write_fds, fd_set *except_fds, struct timeval *timeout)
Описатели файла, заданные read_fds аргументом проверяются, являются ли они готовыми для чтения; write_fds описатели файла проверяются, являются ли они готовыми записи; и except_fds описатели файла задают исключительные условия. Вы можете передавать пустой указатель для любого из этих аргументов, если Вы не заинтересованы проверкой этого вида условия.
'Исключительные условия' не означают, что ошибки сообщаются немедленно, когда выполнен ошибочный системный вызов. Они включают условия, типа присутствия срочного сообщения на гнезде. (См. Главу 11 [Гнезда], для уточнения информации о срочных сообщениях.)
Функция выбора проверяет только первые nfds описателей файла. Обычно она передает FD_SETSIZE как значение этого аргумента.
Блокировка по времени определяет максимальное время ожидания. Если Вы передаете пустой указатель в качестве этого аргумента, это означает, что блокировать неопределенно, пока один из описателей файла не готов. Иначе, Вы должны обеспечить время в формате struct timeval; см. Раздел 17.2.2 [Календарь с высоким разрешением]. Определите нуль как время (struct timeval содержащий все нули) если Вы хотите выяснять, какие описатели готовы в данный момент, без ожидания.
Нормальное возвращаемое значение - общее число готовых описателей файла во всех наборах. Каждый из наборов аргументов записан поверх информацией относительно описателей, которые являются готовыми для соответствующей операции. Таким образом, чтобы видеть, готов ли данный описатель desc для ввода, используйте FD_ISSET (desc, read_fds) после возврата select.
Если select возвращается, потому что период блокировки по времени истекает, то возвращаемое значение - нуль.
Любой сигнал заставит select возвращаться немедленно. Так, если ваша программа использует сигналы, Вы не можете полагаться на select, чтобы ждать полное заданное время. Если Вы хотите убедиться в правильности ожидания, Вы должны проверить EINTR и повторять select с расчетной блокировкой по времени, основанной на текущем времени. См. пример ниже. См. также Раздел 21.5 [Прерванные Примитивы].
Если происходит ошибка, select возвращает -1 и не изменяет аргумент наборов описателей файла. Следующие errno условия ошибки определены для этой функции:
Один из набора описателей файла определил недопустимый дескриптор файла.
Операция была прервана сигналом. См. Раздел 21.5 [Прерванные Примитивы].
Аргумент блокировки по времени недопустим; один из компонентов отрицателен или слишком большой.
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/time.h>
int
input_timeout (int filedes, unsigned int seconds)
{
fd_set set;
struct timeval timeout;
/* Инициализируем набор дескрипторов файлов. */
FD_ZERO (&set);
FD_SET (filedes, &set);
/* Инициализируем структуру timeout. */
timeout.tv_sec = seconds;
timeout.tv_usec = 0;
/* `select' returns 0 if timeout, 1 if input available, -1 if error.
*/
return TEMP_FAILURE_RETRY (select (FD_SETSIZE,
&set, NULL, NULL,
&timeout));
}
int
main (void)
{
fprintf (stderr, 'select returned %d.\n',
input_timeout (STDIN_FILENO, 5));
return 0;
}
Этот раздел описывает, как Вы можете выполнять различные другие операции с дескрипторами файла, типа запроса или установки флагов, описывающих состояние описателя файла, манипулирования блокировками записи, и т.п.. Все эти операции выполняются функцией fcntl.
Второй аргумент fcntl функции - команда, которая определяет которую операцию выполнить. Функция и макрокоманды, которые обозначают различные флаги, объявлены в заглавном файле 'fcntl.h'. (Многие из этих флагов также используются функцией open; см. Раздел 8.1 [Открытие и Закрытие Файлов].)
Функция fcntl выполняет операцию, заданную командой, на описателе файла filedes. Некоторые команды требуют, чтобы были обеспечены дополнительные аргументы. Эти дополнительные аргументы и возвращаемое значение и условия ошибки даны в детализированных описаниях индивидуальных команд.
Вот краткий список различных команд.
Дублирует дескриптор файла (возвращает другой дескриптор файла, указывающий на тот же самый открытый файл). См. Раздел 8.8 [Дублирование Дескрипторов].
Получает флаги, связанные с описателем файла. См. Раздел 8.9 [Дескрипторные Флаги]. F_SETFD Устанавливает флаги, связанные с дескриптором файла. См. Раздел 8.9 [Дескрипторные Флаги].
Получает флаги, связанные с открытым файлом. См. Раздел 8.10 [Флаги Состояния Файла].
Устанавливает флаги, связанные с открытым файлом. См. Раздел 8.10 [Флаги Состояния Файла].
Получает блокировку файла. См. Раздел 8.11 [Блокировки Файла].
Устанавливает или снимает блокировку файла. См. Раздел 8.11 [Блокировки Файла].
Подобен F_SETLK, но ждет завершения. См. Раздел 8.11 [Блокировки Файла].
Получает процесс или ID группы процессов, чтобы получить сигналы SIGIO. См. Раздел 8.12 [Ввод Прерывания].
Устанавливает процесс или ID группы процессов, чтобы получить сигналы SIGIO. См. Раздел 8.12 [Ввод Прерывания].
Вы можете дублировать дескриптор файла, или зарезервировать другой дескриптор файла, который относится к тому же самому открытому файлу, что и первый. Двойные дескрипторы совместно используют одну и ту же файловую позицию и один набор флагов состояния файла (см. Раздел 8.10 [Флаги Состояния Файла]), но каждый имеет собственный набор флагов дескриптора файла (см. Раздел 8.9 [Дескрипторные Флаги]).
Основное использование дублирования дескриптора файла это переадресация ввода или вывода: то есть замена файла или канала, которому указанный дескриптор файла соответствует.
Вы можете выполнять эту операцию, используя fcntl функцию с командой F_DUPFD, но имеются также удобные функции dup и dup2 для дублирования дескрипторов.
Fcntl функция и флаги объявлена в 'fcntl.h', в то время как прототипы для dup и dup2 находятся в файле 'unistd.h'.
Эта функция копирует дескриптор old в первый доступный дескрипторный номер (первый номер не открытый сейчас). Это эквивалентно fcntl (old, F_DUPFD, 0).
Эта функция копирует дескриптор old в дескриптор new.
Если оld - недопустимый дескриптор, то dup2 не делает ничего. Иначе, новый дубликат old заменяет любое предыдущее значение дескриптора new, как будто он был закрыт сначала.
Если оld и new - различные числа, и old - допустимый дескрипторный номер, то dup2 эквивалентен:
close (new);
fcntl (old, F_DUPFD, new)
Эта макрокоманда используется как аргумент команды fcntl, для копирования дескриптора файла, данного как первый аргумент.
Форма обращения в этом случае:
fcntl (old, F_DUPFD, next_filedes)
Возвращаемое значение из fcntl с этой командой - обычно значение нового дескриптора файла. Возвращаемое значение -1 указывает ошибку. Следующие errno условия ошибки определены для этой команды:
Аргумент old недопустим.
Next_filedes аргумент недопустим.
Дескрипторов файла, доступных вашей программе, больще нет.
- не возможный код ошибки для dup2, потому что dup2 не создает новое открытие файла; двойные дескрипторные подпадают под ограничение, которое указывает ENFILE.
возможен, потому что это относится к ограничению различных дескрипторных чисел для использования в одном процессе.
Вот пример, показывающий, как использовать dup2, чтобы делать переадресацию. Обычно, переадресация стандартных потоков (подобно stdin) выполняется командным интерпретатором или подобной программой перед вызовом одной из запускаемых функций (см. Раздел 23.5 [Выполнение Файла]) чтобы выполнить новую программу в дочернем процессе. Когда новая программа выполнена, она создает и инициализирует стандартные потоки, чтобы указать на соответствующие дескрипторы файла, прежде, чем функция main вызывается.
Так, чтобы переназначить стандартный ввод в файл, оболочка могла бы делать что - нибудь вроде:
pid = fork ();
if (pid == 0)
{
char *filename;
char *program;
int file;
. . .
file = TEMP_FAILURE_RETRY (open
(filename, O_RDONLY));
dup2 (file, STDIN_FILENO);
TEMP_FAILURE_RETRY (close (file));
execv (program, NULL);
}
Флаги дескриптора Файла - разнообразные атрибуты дескриптора файла. Эти флаги связаны со специфическими дескрипторами файла, так, что если Вы создаете двойные дескрипторы файла из одиночного открытия файла, то каждый дескриптор имеет собственный набор флагов.
В настоящее время имеется только один флаг дескриптора файла: FD_CLOEXEC, который заставляет дескриптор быть закрытым если Вы используете любую из запускаемых функций (см. Раздел 23.5 [Выполнение Файла]).
Символы в этом разделе определены в заглавном файле 'fcntl.h'.
Эта макрокоманда используется как аргумент команды fcntl, чтобы определять, что она должна возвратить флаги дескриптора файла, связанные с filedes аргументом.
Нормальное возвращаемое значение из fcntl с этой командой неотрицательное число, которое может интерпретироваться как поразрядное OR индивидуальных флагов (за исключением того, что в настоящее время имеется только один флаг).
В случае ошибки, fcntl возвращает -1. Следующие errno условия ошибки определены для этой команды:
Эта макрокоманда используется как аргумент команды fcntl, для определения, что она должна установить флаги дескриптора файла, связанные с filedes аргументом. Она требует третий int аргумент, чтобы определить новые флаги, так что форма обращения:
fcntl (filedes, F_SETFD, new_flags)
Следующая макрокоманда определена для использования как флаг дескриптора файла с fcntl функцией. Значение - константа integer пригодное для использования как значение битовой маски.
Этот флаг определяет, что дескриптор файла должен быть закрыт, когда вызывается запускаемая функция; см. Раздел 23.5 [Выполнение Файл]. Когда дескриптор файла размещен (как с open или dup), этот бит первоначально очищен на новом описателе файла, означая, что дескриптор останется в живых в новой программе после запуска.
Если Вы хотите изменять флаги дескриптора файла, Вы должны получить текущие флаги с F_GETFD и изменять значение. Не думайте, что флаги, перечисленные здесь - единственные, которые реализованы, ваша программа может быть будет выполняться через годы, и тогда может существовать большее количество флагов. Например, вот функция, чтобы устанавливать или очистить флаг FD_CLOEXEC без того, чтобы изменять любые другие флаги:
int
set_cloexec_flag (int desc, int value)
{
int oldflags = fcntl (desc, F_GETFD, 0);
if (oldflags < 0)
return oldflags;
/* Установим только флаг который мы хотим
установить. */
if (value != 0)
oldflags |= FD_CLOEXEC;
else
oldflags &= ~FD_CLOEXEC;
return fcntl (desc, F_SETFD, oldflags);
}
Флаги состояния Файла используются, чтобы определить атрибуты открытия файла. В отличие от флагов дескриптора файла, обсужденных в Разделе 8.9 [Дескрипторные Флаги], флаги состояния файла разделяются дублированными дескрипторами файла, следующими из одиночного открытия файла.
Флаги состояния файла инициализируются функцией open из аргумента флагов функции open. Некоторые из флагов значимы только в open и не вспоминаются впоследствии; многие из оставшихся не могут впоследствии быть изменены, хотя Вы можете читать их значения, исследуя флаги состояния файла.
Несколько флагов состояния файла могут быть изменены, в любое время используя fcntl. Они включают O_APPEND и O_NONBLOCK.
Символы в этом разделе определены в заглавном файле 'fcntl.h'.
Эта макрокоманда используется как аргумент команды fcntl, для чтения флагов состояния файла для файла открытого с описателем filedes.
Нормальное возвращаемое значение из fcntl с этой командой неотрицательное число, которое может интерпретироваться как поразрядное ИЛИ индивидуальных флагов. Флаги закодированы так же, как аргумент флагов для open (см. Раздел 8.1 [Открытие и Закрытие Файлов]), но здесь значимы только режимы доступа файла и O_APPEND и O_NONBLOCK флаги. Так как режимы доступа файла - не одноразрядные значения, Вы можете маскировать другие биты в возвращенных флагах с O_ACCMODE, чтобы сравнить их.
В случае ошибки, fcntl возвращает -1. Следующие errno условия ошибки определены для этой команды:
Эта макрокоманда используется как аргумент команды fcntl, для установки флагов состояния файла для открытого файла, соответствующего filedes аргументу. Эта команда требует третьего int аргумента, чтобы определить новые флаги, так что обращение походит на это:
fcntl (filedes, F_SETFL, new_flags)
Нормальное возвращаемое значение из fcntl с этой командой неопределенное значение отличное от -1, которое указывает ошибку. Условия ошибки - такие же как для команды F_GETFL.
Следующие макрокоманды определены для анализа и построения значений флага состояния файла:
Эта макрокоманда замещает маску, которая может быть поразрядна AND со значением флага состояния файла, чтобы произвести значение, представляющее режим доступа файла. Режим будет O_RDONLY, O_WRONLY, или O_RDWR.
O_RDONLY Открывает файл для чтения.
O_WRONLY Открывает файл для записи.
O_RDWR Открывает файл, и для чтения и для записи.
int
set_nonblock_flag (int desc, int value)
{
int oldflags = fcntl (desc, F_GETFL, 0);
if (oldflags < 0)
return oldflags;
if (value != 0)
oldflags |= O_NONBLOCK;
else
oldflags &= ~O_NONBLOCK;
return fcntl (desc, F_SETFL, oldflags);
}
Остающиеся команды fcntl используются, чтобы поддерживать блокировку записей, который разрешает многим сотрудничающим программам предохранять друг друга от одновременного доступа к частям файла ошибочным способом.
Исключительная блокировка или блокировка записи дает монопольный доступ процессу для записи в заданной части файла. В то время как установлена блокировка никакой другой процесс не может блокировать эту часть файла.
Общедоступная блокировка или блокировка чтения запрещает любому другому процессу запрос блокировки записи в заданной части файла. Однако, другие процессы могут запрашивать блокировки чтения.
Функции read и write фактически не выясняет, имеются ли блокировки в данном месте.
Если Вы хотите выполнять протокол блокировки для файла, общедоступного многократными процессами, ваше приложение, должно делать явные обращения fcntl, чтобы запрашивать и очистить блокировки в соответствующих пунктах.
Блокировки связаны с процессами. Процесс может иметь только один вид набора блокировок для каждого байта данного файла. Когда любой дескриптор файла для того файла закрыт процессом, все блокировки, которые обрабатывают связи с тем файлом, опущены, даже если блокировки были сделаны, используя другие описатели, которые остаются открытыми. Аналогично, блокировки опущены, когда процесс выходит, и не наследуются дочерними созданными процессами (см. Раздел 23.4 [Создание Процесса]).
При создании блокировки, используйте struct flock, чтобы определить какую блокировку и где Вы хотите выполнить. Этот тип данных и связанные макрокоманды для fcntl функции объявлен в заглавном файле 'fcntl.h'.
struct flock (тип данных)
Эта структура используется с fcntl функцией, чтобы описать блокировку файла. Она имеет следующие элементы:
short int l_type
short int l_whence
off_t l_start
off_t l_len
pid_t l_pid
Эта макрокоманда используется как аргумент команды fcntl, для определения, что она должна получить информацию относительно блокировки. Эта команда требует третьего аргумента типа struct flock *, чтобы быть переданной к fcntl, так, чтобы форма обращения была:
fcntl (filedes, F_GETLK, lockp)
Вы должны определить тип блокировки F_WRLCK, если Вы хотите выяснять относительно блокировок чтения и записи, или F_RDLCK, если Вы хотите выяснять относительно блокировок только записи.
Может иметься больше чем одна блокировка, воздействующая на область, заданную lockp аргументом, но fcntl только возвращает информацию относительно одной из них. l_whence элемент структуры lockp установлен в SEEK_SET и l_start и l_len набор полей, чтобы идентифицировать блокированную область.
Если никакая блокировка не применяется, единственное изменение для структуры lockp, должно модифицировать l_type в значение F_UNLCK.
Нормальное возвращаемое значение из fcntl с этой командой неопределенное значение отличное от -1, которое зарезервировано, чтобы указать ошибку. Следующие errno условия ошибки определены для этой команды:
Или lockp аргумент не определяет допустимую информацию блокировки, или файл, связанный с filedes не поддерживает блокировки.
Эта макрокоманда используется как аргумент команды fcntl, для определения, что она должна установить или снять блокировку. Эта команда требует третьего аргумента типа struct flock *, так, чтобы форма обращения была:
fcntl (filedes, F_SETLK, lockp)
Если блокировка не может быть установлена, fcntl возвращается немедленно со значением -1. Эта функция не блокирует ожидание пока другие процессы снимут блокировки. Если fcntl преуспевает, она возвращает значение отличное от -1.
Следующие errno условия ошибки определены для этой функции:
Блокировка не может быть установлена, потому что это блокировано существующей блокировкой на файле.
Некоторые системы используют EAGAIN в этом случае, и другие системы используют EACCES; ваша программа должна обработать их одинаково, после F_SETLK.
Также: filedes аргумент недопустим; Вы запросили блокировку чтения, но filedes - не открыт для чтения; или, Вы запросили блокировку записи, но filedes - не открыт для записи.
Или lockp аргумент определяет недопустимую информацию блокировки, или файл, связанный с filedes не поддерживает блокировки.
Система работает без ресурсов блокировки файла; имеются уже слишком много блокировок файла.
Хорошо разработанные файловые системы никогда не сообщают эту ошибку, потому что они не имеют никакого ограничения на число блокировок. Однако, Вы должны все еще принимать во внимание возможности этой ошибки, поскольку это может следовать из доступа к сети к файловой системе на другой машине.
Эта макрокоманда используется как аргумент команды fcntl, для определения, что она должна установить или снять блокировку. Это тоже что команда F_SETLK, но заставляет процесс блокировать (или ждать) пока запрос не будет определен.
Эта команда требует третьего аргумента типа struct flock *, как для команды F_SETLK.
Fcntl возвращаемые значения и ошибки - те же что для команды F_SETLK, но эти дополнительные errno условия ошибки определены для этой команды:
Функция была прервана сигналом, во время ожидания. См. Раздел 21.5 [Прерванные Примитивы].
Было обнаружено условие тупика. Это может случаться, если два процесса каждый из которых управляет уже заблокированной областью запрашивают блокировку на области, блокированной другим процессом.
Следующие макрокоманды определены для использования как значения для l_type элемента структуры flock. Значения - константы integer.
Эта макрокоманда используется, чтобы установить блокировку чтения.
Эта макрокоманда используется, чтобы установить блокировку записи.
Эта макрокоманда используется, чтобы установить, что область разблокируется.
Наличие многократных копий программы, одновременно пишущих в файл может сделать содержимое файла бессмысленным. Но Вы можете предотвратить эту проблему, устанавливая блокировку записи на файле перед фактической записью в файл.
Если программа также нуждается в чтении из файла и хочет удостовериться, что содержимое файла находится в непротиворечивом состоянии, то она может также использовать блокировку чтения. В то время как блокировка чтения установлена, никакой другой процесс не может блокировать эту часть файла для записи.
Не забудьте, что блокировки файла - только произвольный протокол для управления доступом к файлу. Все еще имеется возможность для доступа к файлу программами, которые не используют протокол блокировки.
Если Вы устанавливаете FASYNC флаг состояния на дескрипторе файла (см. Раздел 8.10 [Флаги Состояния Файла]), сигнал SIGIO посланы всякий раз, когда производится ввод или вывод, становится возможным на этом описателе файла. Процесс или группа процессов, может быть выбрана чтобы получить сигнал, используя команду F_SETOWN для fcntl функции. Если дескриптор файла является гнездом, он также, выбирает получателя сигналов SIGURG, которые возникают, когда внепоточные данные прибывает в это гнездо; см. Раздел 11.8.8 [Внепоточные Данные].
Если дескриптор файла соответствует терминалу, то SIGIO сигналы посылаются группе приоритетного процесса терминала. См. Главу 24 [Управление заданиями].
Символы в этом разделе определены в заглавном файле 'fcntl.h'.
Эта макрокоманда используется как аргумент команды fcntl, для определения того, что она должна получить информацию относительно процесса или группы процессов, которой посланы сигналы SIGIO. (Для терминала, это - фактически приоритетный ID группы процессов, которую Вы можете получать использованием tcgetpgrp; см. Раздел 24.7.3 [Функции Доступа Терминала].)
Возвращаемое значение интерпретируется как ID процесса; если оно отрицательно, то абсолютное значение - ID группы процессов.
Следующее errno условие ошибки определено для этой команды:
Filedes аргумент недопустим.
fcntl (filedes, F_SETOWN, pid)
Возвращаемое значение из fcntl с этой командой - -1 в случае ошибки и некоторое другого значения если обращение успешно. Следующие errno условия ошибки определены для этой команды:
Filedes аргумент недопустим.
Не имеется никакого процесса или группы процессов, соответствующей pid.
Эта глава описывает функции библиотеки GNU C для управления файлами. В отличие от функций ввода и функций вывода, описанных в Главе 7 [ввод - вывод на Потоках] и Главе 8 [ввод - вывод низкого уровня], эти функции имеют отношение к действиям на файлах непосредственно.
Среди средств, описанных в этой главе - функции для исследования или изменения каталогов, функции для переименования и удаления файлов, и функции для исследования и установки атрибутов файла типа прав доступа и изменения времени.
Каждый процесс связанный с этим каталогом, называемым текущим рабочим каталогом или просто рабочим каталогом, который используется в уточнении имен файла прямого доступа (см. Раздел 6.2.2 [Уточнение Имени файла]).
Когда Вы регистрируетесь в системе и начинаете новый сеанс, ваш рабочий каталог первоначально устанавливается в исходный каталог, связанный с вашим логическим входом в систему в базе данных пользователей системы. Вы можете находить исходный каталог любого пользователя, используются getpwuid или getpwnam функции; см. Раздел 25.12 [База данных Пользователей].
Пользователи могут изменять рабочий каталог, используя команды оболочки подобно cd. Функции, описанные в этом разделе - примитивы, используемые командами и другими программами для исследования и изменения рабочего каталога.
Прототипы для этих функций объявлены в файле 'unistd.h'.
char * getcwd (char *buffer, size_t size) (функция)
Версия GNU этой функции также разрешает Вам определять пустой указатель для буферного аргумента. Тогда getcwd зарезервирует буфер автоматически, как malloc (см. Раздел 3.3 [Беспрепятственное Резервирование]).
Возвращаемое значение - буфер в случае успеха и пустой указатель при отказе. Следующие errno условия ошибки определены для этой функции:
аргумент size - нуль, и буфер - не пустой указатель.
аргумент size - меньше чем длина имени рабочего каталога.
Вы должны зарезервировать больший массив и попытаться снова.
Права на чтение или поиск компонент имени файла были превышены.
char *
gnu_getcwd ()
{
int size = 100;
char *buffer = (char *) xmalloc (size);
while (1)
{
char*value = getcwd(buffer,size);
if (value != 0)
return buffer;
size *= 2;
free (buffer);
buffer = (char *) xmalloc (size);
}
}
char * getwd (char *buffer) (функция)
-Функция: int chdir (const char *filename)
Нормальное, успешное возвращаемое значение из chdir - 0. Значение -1 возвращается, чтобы указать ошибку. Errno условия ошибки, определенные для этой функции - обычные синтаксические ошибки имени файла (см. Раздел 6.2.3 [Ошибки Имени файла]), плюс ENOTDIR, если filename файла - не каталог.
Средства, описанные в этом разделе допускают Вам читать содержимое файла каталога. Это полезно, если Вы хотите, чтобы ваша программа перечислила все файлы в каталоге, возможно как часть меню.
Opendir функция открывает поток каталога, чьи элементы являются входами каталога. Вы используете readdir функцию на потоке каталога, чтобы отыскать эти входы, представляемые как объекты struct dirent. Имя файла для каждого входа сохранено в d_name элементе этой структуры. Имеются очевидные параллели здесь со средствами потока для обычных файлов, описанных в Главе 7 [ввод вывод на Потоках].
Этот раздел описывает то, что Вы находите входя в каталога, поскольку Вы могли бы получать это из потока каталога. Все символы объявлены в заглавном файле 'dirent.h'.
Это - тип структуры, используемый, чтобы возвратить информацию относительно входов в каталог. Она содержит следующие поля:
char *d_name
ino_t d_fileno
size_t d_namlen
Эта структура в будущем может содержать дополнительные элементы.
Когда файл имеет многочисленные имена, каждое имя имеет собственный вход в каталог. Единственный способ которым Вы можете сообщать, что входы каталога принадлежат одиночному файлу - это, если они имеют то же самое значение для d_fileno поля.
Атрибуты Файла типа размера, числа изменений, и т.п. - часть файла непосредственно, см. Раздел 9.8 [Атрибуты Файла].
Этот раздел описывает, как открыть поток каталога. Все символы объявлены в заглавном файле 'dirent.h'.
Тип данных DIR представляет поток каталога.
Вы не должны когда-либо резервировать объекты struct dirent или типов данных DIR, так как функции доступа каталога делают это для Вас. Вместо этого, Вы обращаетесь к этим объектам, используя указатели, возвращенные следующими функциями.
DIR * opendir (const char *dirname) (функция)
Если происходит ошибка opendir возвращает пустой указатель. В дополнение к обычным синтаксическим ошибкам имени файла (см. Раздел 6.2.3 [Имя файла Errors]), следующие errno условия ошибки определены для этой функции:
содержит каталог, не может поддерживать любые дополнительные открытые файлы в настоящее время. (Эта проблема не может случаться в системе GNU.)
Тип DIR обычно реализован, используя дескриптор файла, а opendir функция в терминах функции open. См. Главу 8 [ввод - вывод низкого уровня]. Потоки Каталога и основные дескрипторы файла закрываются при запуске (см. Раздел 23.5 [выполнение Файла]).
Этот раздел описывает, как читать входы каталога из потока каталога, и как закрыть поток, когда Вы закончили работу с ним. Все символы объявлены в файле 'dirent.h'.
struct dirent * readdir (DIR *dirstream) (функция)
Примечание Переносимости: На некоторых системах, readdir не может возвращать входы для '. ' и ' .. ', даже если они - всегда допустимые имена файла в любом каталоге. См. Раздел 6.2.2 [Уточнение Имени файла].
Если нет больше входов в каталоге, или обнаружена ошибка, readdir возвращает пустой указатель. Следующие errno условия ошибки определены для этой функции:
irstream аргумент не допустим.
int closedir (DIR *dirstream) (функция)
Следующие errno условия ошибки определены для этой функции:
dirstream аргумент не допустим.
Имеется простая программа, которая печатает имена файлов в текущем рабочем каталоге:
#include <stddef.h>
#include <stdio.h>
#include <sys/types.h>
#include <dirent.h>
int
main (void)
{
DIR *dp;
struct dirent *ep;
dp = opendir ('./');
if (dp != NULL)
{
while (ep = readdir (dp))
puts (ep->d_name);
(void) closedir (dp);
}
else
puts ('Couldn't open the directory.');
return 0;
}
Этот раздел описывает, как повторно читать части каталога, который Вы уже читали из открытого потока каталога. Все символы объявлены в заглавном файле 'dirent.h'.
void rewinddir (DIR *dirstream) (функция)
off_t telldir (DIR *dirstream) (функция)
void seekdir (DIR *dirstream, off_t pos) Function
Значение pos должно быть результатом предыдущего обращения к telldir на этом специфическом потоке; закрытие и повторное открытие каталога может объявить неверным значения, возвращенные telldir.
В POSIX системах, один файл может иметь много имен в то же самое время. Все имена в равной степени реальны, и никакое из них не лучше других.
Чтобы добавить имя к файлу, используйте функцию link. (Новое имя также называется жесткой связью с файлом.) Создание нового обращения к файлу не копирует содержимое файла; просто появляется новое имя, под которым файл может быть известен, в дополнение к существующему имени файла (или именам).
Один файл может иметь имена в отдельных каталогах, так что, организация файловой системы - не строгая иерархия или дерево.
Так как специфический файл существует внутри одиночной файловой системы, все имена должны быть в каталогах в этой файловой системе. Link сообщает ошибку, если Вы пробуете делать жесткое обращение к файлу из другой файловой системы.
Прототип для функции link объявлен в заглавном файле 'unistd.h'.
int link (const char *oldname, const char *newname) (функция)
Эта функция возвращает значение 0, если она успешна и -1 при отказе. В дополнение к обычным синтаксическим ошибкам имени файла (см. Раздел 6.2.3 [Ошибки Имени файла]) и для oldname и newname, следующие errno условия ошибки определены для этой функции:
каталог, в котором link должна написать, нельзя перезаписывать.
имеется уже файл, именованный newname. Если Вы хотите заменить эту ссылку на новую ссылку, Вы должны сначала явно удалить старую ссылку.
имеются уже слишком много связей к файлу, именованному oldname. (Максимальное число связей к файлу - LINK_MAX; см. Раздел 27.6 [Ограничения для Файлов].)
Хорошо разработанные файловые системы никогда не сообщают эту ошибку, потому что они разрешают большее количество связей чем ваш диск мог бы содержать. Однако, Вы должны все еще принимать во внимание возможности этой ошибки, поскольку она могла бы следовать из доступа к сети к файловой системе на другой машине.
файл, именованный oldname не существует. Вы не можете делать ссылок к файлу, который не существует.
каталог или файловая система, которая содержала бы, новую ссылка 'полна' и не может быть расширена.
Некоторые реализации позволяют только привилегированным пользователям делать связи к каталогам, а другие запрещают эту операцию полностью. Эта ошибка используется, чтобы сообщить эту проблему.
Каталог, содержащий новую ссылка не может изменяться, потому что он находится в файловой системе только для чтения.
Каталог, заданный в newname находится в другой файловой системе чем существующий файл.
Система GNU поддерживает связи программного обеспечения или символические связи. Это - вид 'файла', который является по существу указателем на другое имя файла. В отличие от жестких обращений, символические связи могут быть сделаны к каталогам или между файловыми системами без ограничений.
Функция open понимает, что Вы передали имя ссылки, и читает имя файла, вместо этого открывает файл, указываемый ссылкой. Stat функция аналогично функционирует на файле, на который указывает символическая ссылка, а не на связи непосредственно. Как связывается, функция, которая делает жесткое обращение.
Наоборот, другие операции типа удаления или переименования файла воздействуют непосредственно на ссылки. Функции readlink и lstat также воздерживаются от следующих символических ссылок, потому что их цель - получить информацию относительно ссылки.
Прототипы для функций, перечисленных в этом разделе находятся в 'unistd.h'.
Symlink функция делает символическую ссылку к oldname, с именем newname.
Нормальное возвращаемое значение из symlink - 0. Возвращаемое значение -1 указывает ошибку.
В дополнение к обычным синтаксическим ошибкам имени файла (см. Раздел 6.2.3 [Ошибки Имени файла]), следующие errno условия ошибки определены для этой функции:
имеется уже существующий файл по имени newname.
файл newname существовал бы на файловой системе только для чтения.
каталог или файловая система не может быть расширена, чтобы делать новую ссылка.
аппаратная ошибка произошла при чтении или записи данных относительно диска.
Readlink функция получает значение символической filename связи. Имя файла, на которое ссылка указывает, скопировано в буфер. Эта строка имени файла не с нулевым символом в конце; readlink обычно возвращает скопированное число символов. Аргумент size определяет максимальное число символов, для копирования, обычно размер резервирования буфера.
Если возвращаемое значение равняется size, Вы не можете распознать, имелся или нет участок памяти, чтобы возвратить все имя. Так что делайте больший буфер, и вызовите readlink снова. Вот пример:
char *
readlink_malloc (char *filename)
{
int size = 100;
while (1)
{
char *buffer = (char *) xmalloc (size);
int nchars= readlink(filename,buffer,size);
if (nchars < size)
return buffer;
free (buffer);
size *= 2;
}
}
именованный файл - не символическая ссылка.
аппаратная ошибка произошла при чтении или записи данных относительно диска.
Вы можете удалять файл функциями unlink или remove. (Эти имена синонимичны.)
Стирание фактически удаляет имя файла. Если это является только именем файла, то файл удален также. Если файл имеет другие имена также (см. Раздел 9.3 [Жесткие обращения]), то он остается доступным под другими именами.
Функция unlink удаляет filename имя файла. Если это является единственным именем файла, файл непосредственно также удален. (Фактически, если любой процесс работает с файлом, когда это случается, стирание откладывается, пока все процессы не закрыли файл.)
Unlink функция объявлена в заглавном файле 'unistd.h'.
Эта функция возвращает 0 при успешном завершении, и -1 при ошибке. В дополнение к обычным синтаксическим ошибкам имени файла (см. Раздел 6.2.3 [Имя файла Errors]), следующие errno условия ошибки определены для этой функции:
право записи отклонено для каталога из которого файл должен быть удален.
Эта ошибка указывает, что файл используется системой таким способом, что он не может быть удален.
имя файла, которое будет удалено не существует.
На некоторых системах, unlink не может использоваться, чтобы удалить имя каталога, или может использоваться только привилегированным пользователем. Чтобы избегать таких проблем, используйте rmdir, чтобы удалить каталоги.
Каталог, в котором имя файла должно быть удалено, находится в файловой системе только для чтения, и не может изменяться.
Функция remove - другое имя для unlink. Remove - имя ANSI C, в то время как unlink - POSIX.1 имя. Remove имя объявлено в 'stdio.h'.
Rmdir функция удаляет каталог. Каталог должен быть пуст прежде, чем он может быть удален; другими словами, он может только содержать элементы '. ' и ' .. '.
В большинстве других отношений, rmdir ведет себя подобно unlink. Имеются два дополнительных errno условия ошибки, определенные для rmdir:
Каталог, который будет удален не пуст.
Прототип для этой функции объявлен в заглавном файле 'unistd.h'.
Функция rename используется, чтобы заменить имя файла.
int rename (const char *oldname, const char *newname) (функция)
Каталог, содержащий имя newname должен быть в той же самой файловой системе как файл (что обозначен именем oldname).
Один частный случай для rename - то, когда oldname и newname два имени для того же самого файла. Непротиворечивый способ обрабатывать этот случай состоит в том, чтобы удалить oldname. Однако, POSIX говорит, что rename в этом случае не делает ничего, и не сообщает об ошибке. Мы не знаем то, что ваша операционная система будет делать. Система GNU будет возможно делать правильно (удалять oldname) если Вы явно не запрашиваете строгую POSIX совместимость 'даже когда она причиняет вред'.
Если oldname - не каталог, то любой существующий файл, именованный newname, удален в течение операции переименования. Однако, если newname - имя каталога, происходит сбой rename в этом случае.
Если oldname является каталогом, то или newname, не должен существовать, или должен быть указан каталог, который является пустым. В последнем случае, существующий каталог, именованный newname удален сначала. Имя newname не должно определить подкаталог каталога oldname, который переименовывается.
Если rename терпит неудачу, она возвращает -1. В дополнение к обычным синтаксическим ошибкам имени файла (см. Раздел 6.2.3 [Имя файла Errors]), следующие errno условия ошибки определены для этой функции:
Один из каталогов, содержащих newname или oldname отказывает в записи; или newname и oldname - каталоги, и в праве записи отказано для одного из них.
Каталог, именованный oldname или newname используется системой способом, который предотвращает переименование во время работы. Это включает каталоги, которые являются точками крепления для filesystems, и каталогов, которые являются текущими рабочими каталогами процессов.
каталог newname существует.
Каталог newname не пуст.
oldname - каталог, который содержит newname.
newname называет каталог, а oldname нет.
Каталог предыдущего уровня newname имел бы слишком много связей.
Хорошо разработанные файловые системы никогда не сообщают эту ошибку, потому что они разрешают большое количество связей чем ваш диск, мог бы содержать. Однако, Вы должны все еще принимать во внимание возможности этой ошибки, поскольку она могла бы следовать из доступа к сети к файловой системе на другой машине.
файл, именованный oldname не существует.
каталог, который содержал бы, newname не имеет никакого участка памяти для другого входа, и нет никакого места, оставшегося в файловой системе, чтобы расширить его.
Операция включила бы запись в каталогу на файловой системе только для чтения.
Два имени файла newname и oldnames находятся в различных файловых системах.
Каталоги создаются функцией mkdir. (Имеется также команда оболочки mkdir, которая делает то же самое.)
-Функция: int mkdir (const char *filename, mode_t mode)
Mode аргумент определяет права файла для нового файла каталога. См. Раздел 9.8.5 [Биты Прав], для получения более подробной информации об этом.
Возвращаемое значение 0 указывает на успешное завершение, а -1 указывает на отказ. В дополнение к обычным синтаксическим ошибкам имени файла (см. Раздел 6.2.3 [Ошибки Имени файла]), следующие errno условия ошибки определены для этой функции:
право записи отклонено для директории предыдущего уровня, в которую новый каталог должен быть добавлен.
файл, именованный filename уже существует.
директория предыдущего уровня имеет слишком много связей.
Хорошо разработанные файловые системы никогда не сообщают эту ошибку, потому что они разрешают большое количество связей чем ваш диск мог бы содержать. Однако, Вы должны все еще принимать во внимание возможности этой ошибки, поскольку она могла бы следовать из доступа к сети к файловой системе на другой машине.
файловая система не имеет достаточного участка памяти, чтобы создать новый каталог.
Директория предыдущего уровня создаваемого каталога находится в файловой системе только для чтения, и не может изменяться.
Когда Вы применяете 'ls -l' команду оболочки на файле, это дает Вам информацию относительно размера файла, кто его хозяин, когда было последнее изменение, и т.п.. Этот вид информации называется атрибутами файла; они связаны с файлом непосредственно и не часть одного из имен.
Этот раздел содержит информацию относительно того, как Вы можете запрашивать и изменять эти атрибуты файлов.
Когда Вы читаете атрибуты файла, они возвращаются в структуре, называемой struct stat. Этот раздел описывает имена атрибутов, их типов данных, и что они означают.
Заглавный файл 'sys/stat.h' объявляет все символы, определенные в этом разделе.
struct stat (тип данных)
mode_t st_mode
ino_t st_ino
dev_t st_dev
nlink_t st_nlink
uid_t st_uid
gid_t st_gid
off_t st_size
time_t st_atime
unsigned long int st_atime_usec
time_t st_mtime
unsigned long int st_mtime_usec
time_t st_ctime
unsigned long int st_ctime_usec
unsigned int st_nblocks
Число блоков диска не строго пропорционально размеру файла, по двум причинам: файловая система может использовать, некоторые блоки для внутреннего хранения записи; и файл может быть разреженен, т. е. может иметь 'отверстия', которые содержат нули, но фактически не занимают пространство на диске.
Вы можете узнать (приблизительно) является ли файл разреженен, сравнивая это значение с st_size, примерно так:
(st.st_blocks * 512 < st.st_size)
unsigned int st_blksize
Некоторые из атрибутов файла имеют специальные имена типа данных, которые существуют специально для этих атрибутов. (Они все побочные результаты исследования для общеизвестных типов integer, которые Вы знаете и любите.) Эти typedef-имена определены в заглавном файле 'sys/types.h' также как в 'sys/stat.h'. Вот их список:
mode_t (тип данных)
ino_t (тип данных)
dev_t (тип данных)
nlink_t (тип данных)
Чтобы исследовать атрибуты файлов, используйте функции stat, fstat и lstat. Они возвращают информацию атрибута в объекте struct stat. Все три функции объявлены в заглавном файле 'sys/stat.h'.
int stat (const char *filename, struct stat *buf ) (функция)
Если filename - имя символической связи, атрибуты, которые Вы получаете, описывают файл, на который ссылка указывает. Если ссылка направляет на несуществующее имя файла, то stat сбоит, сообщая несуществующий файл.
Возвращаемое значение - 0, если операция успешна, и -1 при отказе. В дополнение к обычным синтаксическим ошибкам имени файла (см. Раздел 6.2.3 [Ошибки Имени файла], следующие errno условия ошибки определены для этой функции:
файл, именованный filename не существует.
int fstat (int filedes, struct stat *buf ) (функция)
Подобно stat, fstat возвращает 0 при успехе и -1 при отказе. Следующие errno условия ошибки определены для fstat:
filedes аргумент - не допустимый дескриптор файла.
int lstat (const char *filename, struct stat *buf ) (функция)
Режим файла, сохраненный в st_mode поле атрибутов файла, содержит два вида информации: код типа файла, и биты прав доступа. Этот раздел обсуждает только код типа, который Вы можете использовать, чтобы сообщить является ли файл каталогом, является ли он гнездом, и так далее. Для уточнения информации относительно права доступа см. Раздел 9.8.5 [Биты Прав].
Имеются два предопределенных способа, которыми Вы можете обращаться к типу файла. Прежде всего для каждого типа файла, имеется макрокоманда предиката, которая исследует значение режима файла и возвращает истину или ложь если файл того типа, или нет. Во-вторых, Вы можете маскировать снаружи остальную часть режима файла, чтобы получить только код типа файла. Вы можете сравнивать его c различными константами типов файлов.
Все символы, перечисленные в этом разделе определены в заглавном файле 'sys/stat.h'.
Следующие макрокоманды предиката проверяют тип файла, заданный значением m, которое является st_mode полем, возвращенным stat на этом файле:
int S_ISDIR (mode_t m) (макрос)
int S_ISCHR (mode_t m) (макрос)
int S_ISBLK (mode_t m) (макрос)
int S_ISREG (mode_t m) (макрос)
int S_ISFIFO (mode_t m) (макрос)
int S_ISLNK (mode_t m) (макрос)
int S_ISSOCK (mode_t m) (макрос)
Альтернативный, не-POSIX метод тестирования типа файла обеспечивается для совместимости с BSD.
Режим можно поразрядно AND с S_IFMT, чтобы извлечь лод типа файл, и сравнить с соответствующей константой кода типа. Например,
S_ISCHR (mode)
((mode & S_IFMT) == S_IFCHR)
int S_IFMT (макрос)
Вот символические имена для различных типов файлов:
S_IFDIR Эта макрокоманда представляет значение кода типа файла для файла каталога.
S_IFCHR Эта макрокоманда представляет значение кода типа файла для файла - устройства с символьной организацией.
S_IFBLK Эта макрокоманда представляет значение кода типа файла для блочно-ориентированного файла.
S_IFREG Эта макрокоманда представляет значение кода типа файла для регулярного(правильного) файла.
S_IFLNK Эта макрокоманда представляет значение кода типа файла для символической связи.
S_IFSOCK Эта макрокоманда представляет значение кода типа файла для гнезда.
S_IFIFO Эта макрокоманда представляет значение кода типа файла для FIFO или канала.
Каждый файл имеет владельца, который является одним из зарегистрированных имен пользователей, определенных в системе. Каждый файл также имеет группу, которая является одной из определенных групп. Владелец файла может часто быть полезен, но его основная цель - управление доступом.
Владелец файла и группа играет роль в определении доступа, потому что файл имеет набор битов права доступа для пользователя, который является владельцем, другой набор, для тех, кто принадлежат группе владельца файла, и третий набор битов, которые относятся ко всем остальным. См. Раздел 9.8.6 [Право Доступа]
Когда файл создан, его владелец определяется из пользовательского ID процесса, который создает его.
Вы можете изменять владельца и/или группу владельца существующего файла, используя chown функцию. Это - примитив для chown и chgrp команд оболочки.
Прототип для этой функции объявлен в 'unistd.h'.
int chown (const char *filename, uid_t owner, gid_t group) (функция)
Изменение владельца файла на некоторых системах очищает ID пользователя и ID-группы биты прав файла. (Потому что эти биты не могут соответствовать новому владельцу.) другие биты прав файла не изменяются.
Возвращаемое значение - 0 при успехе и -1 при отказе. В дополнение к обычным синтаксическим ошибкам имени файла (см. Раздел 6.2.3 [Ошибки Имени файла]), следующие errno условия ошибки определены для этой функции:
Этот процесс испытывает недостаток прав, чтобы делать запрошенное изменение.
Только привилегированные пользователи или владелец файла могут изменять группу файла. На большинстве файловых систем, только привилегированные пользователи могут изменять владельца файла; некоторые файловые системы позволяют Вам изменять владельца, если Вы - в настоящее время владелец. Когда Вы обращаетесь к отдаленной файловой системе, поведение, с которым Вы сталкиваетесь, определено системой, которая фактически содержит файл, а не системой, на которой ваша программа выполняется.
См. Раздел 27.7 [Опции для Файлов], для уточнения информации относительно _POSIX_CHOWN_RESTRICTED макрокоманды.
Файл находится в файловой системе только для чтения.
int fchown (int filedes, int owner, int group) (функция)
Возвращаемое значение из fchown - 0 при успехе и -1 при отказе. Следующие errno коды ошибки определены для этой функции:
filedes аргумент - не допустимый дескриптор файла.
filedes аргумент соответствует каналу или гнезду, а не обычному файлу.
Этот процесс испытывает недостаток прав, чтобы делать запрошенное изменение. Для подробностей, см. chmod, выше.
Файл постоянно находится в файловой системе только для чтения.
Этот раздел обсуждает биты права доступа, которые управляют чтением и записью в файл. См. Раздел 9.8.3 [Проверка Типа Файла], для уточнения информации относительно кода типа файла.
Все символы, перечисленные в этом разделе определены в файле 'sys/stat.h'.
Эти символические константы определены для битов режима файла, которые управляют правом доступа для файла:
бит права чтения для владельца файла. На многих системах, этот бит - 0400. S_IREAD - устаревший синоним, предусмотрен для BSD совместимости.
бит права записи для владельца файла. Обычно 0200. S_IWRITE - устаревший синоним, предусмотрен для совместимости с BSD.
бит права записи для владельца файла. Обычно 0100. S_IWRITE - устаревший синоним, предусмотрен для совместимости cBSD.
Это эквивалент ' (S_IRUSR | S_IWUSR | S_IXUSR) '.
бит права чтения для владельца группы файла. Обычно 040.
бит права записи для владельца группы файла. Обычно 020.
бит права выполнения или поиска для владельца группы файла. Обычно 010.
Это эквивалент ' (S_IRGRP | S_IWGRP | S_IXGRP) '.
бит права чтения для других пользователей. Обычно 04.
бит права записи для других пользователей. Обычно 02.
бит права выполнения или поиска для других пользователей. Обычно 01.
Это эквивалент ' (S_IROTH | S_IWOTH | S_IXOTH) '.
бит выполнения, устанавливающий ID-пользователя, обычно 04000.
бит выполнения, устанавливающий ID-группы, обычно 02000.
Это - <sticky> бит, обычно 01000.
На каталоге, sticky бит дает право удалить файл в каталоге, если Вы можете записывать в содержимое этого файла. Обычно, пользователь либо может удалять все файлы в каталоге либо не может удалять никакой из них (имеет ли пользователь право записи для каталога). Липкий бит делает возможным управлять стиранием для индивидуальных файлов.
Фактические битовые значения символов перечислены в таблице выше, так что Вы можете декодировать значения режима файла при отладке ваших программ. Эти битовые значения правильны для большинства систем, но это не гарантируется.
Предупреждение: Запись явных чисел для прав файла - плохая практика. Это не только непереносимо, но также требует от каждого, кто читает вашу программу, помнить то, что означают конкретные биты. Чтобы сделать вашу программу понятной, используйте символические имена.
Операционная система обычно разрешает право доступа к файлу, основываясь на ID пользователя и группы процесса, и на дополнительном ID группы, вместе с битами владельца, группы и битами права файла. Эти понятия обсуждены подробно в Разделе 25.2 [Свойства процесса].
Если ID пользователя процесса соответствует ID владельца файла, то права для чтения, записи, и выполнения/поиска, управляются соответствующими 'пользовательскими' (или 'владельца') битами. Аналогично, если любой из ID группы или дополнительной группы процесса соответствует ID группы владельца файла, то права, управляется битами 'группы'. Иначе, права управляются 'другими' битами.
Привилегированные пользователи, подобно 'root', могут обращаться к любому файлу, независимо от битов права файла. Как частный случай, для выполнения файла даже для привилегированного пользователя, по крайней мере один из битов выполнения должен быть установлен.
Примитивные функции для создания файлов (например, open или mkdir) воспринимают аргумент mode, который определяет права файла. Но заданный mode изменяется маской создания файла процесса, или перед использованием.
Биты, которые установлены в маске создания файла, идентифицируют права, которые должны всегда быть заблокированы для новых файлов. Например, если Вы устанавливаете все 'другие' биты доступа в маске, то новые файлы не доступны вообще для процессов в 'другом' классе, даже если аргумент mode, заданный в функции создания разрешил такой доступ. Другими словами, маска создания файла - дополнение обычных прав доступа, которые Вы хотите предоставить.
Программы которые создают файлы, обычно определяют аргумент mode, который включает все права, которые имеют смысл для специфического файла. Для обычного файла, это обычно право чтения и право записи для всех классов пользователей. Эти права ограничены как определено собственной маской создания файла индивидуального пользователя.
Чтобы изменять право существующего данного файла, вызовите chmod. Эта функция игнорирует маску создания файла; она использует только заданные биты права.
При нормальном использовании, маска создания файла инициализируется при входе пользователя в систему (использованием umask команды оболочки), и наследуется всеми подпроцессами. Прикладные программы обычно не должны заботиться о маске создания файла.
Когда ваша программа должна создать файл и обходить umask для прав доступа, самый простой способ сделать это состоит в том, чтобы использовать fchmod после открытия файла, а не изменять umask.
Фактически, изменение umask обычно делается только оболочками. Они используют umask функцию.
Функции в этом разделе объявлены в 'sys/stat.h'. mode_t umask (mode_t mask) (функция) Umask функция устанавливает маску создания файла текущего процесса, и возвращает предыдущее значение маски создания файла.
Вот пример, показывающий, как читать маску с umask без ее замены:
mode_t
read_umask (void)
{
mask = umask (0);
umask (mask);
}
mode_t getumask (void) (функция)
int chmod (const char *filename, mode_t mode) (функция)
Если filename называет символическую ссылка, chmod изменяет право файла, указанного ссылкаю, а не связи непосредственно. Не имеется фактически никакого способа установить mode связи, который всегда 1.
Эта функция возвращает 0 в случае успеха и -1 если нет. В дополнение к обычным синтаксическим ошибкам имени файла (см. Раздел 6.2.3 [Ошибки Имени файла]), следующие errno условия ошибки определены для этой функции:
Именованный файл не существует.
Этот процесс не имеет права изменить право доступа этого файла. Только владелец файла или привилегированный пользователь может изменять их.
Файл постоянно находится в файловой системе только для чтения.
int fchmod (int filedes, int mode) (функция)
Возвращаемое значение из fchmod - 0 при успехе и -1 при отказе. Следующие errno коды ошибки определены для этой функции:
filedes аргумент - не допустимый дескриптор файла.
filedes аргумент соответствует каналу или гнезду, или кое-чему еще, которое не имеет права доступа.
Этот процесс не имеет права изменить право доступа этого файла. Только владелец файла или привилегированный пользователь может изменять их.
Файл постоянно находится в файловой системе только для чтения.
Когда программа выполняется привилегированным пользователем, это разрешает ей обращаться к файлам без ограничений на пример, изменять ' /etc/passwd '. Программы разработанные, чтобы быть выполненным обычными пользователями, но обращаться к таким файлам используют setuid так, чтобы они всегда выполнялись под root'ом.
Программа должна явно проверить, имел ли пользователь необходимый доступ к файлу, прежде, чем она начнет читать или писать в файл.
Для этого используйте функции доступа, которые проверяет право доступа, основанное на ID пользователя. (setuid не изменяет реального ID пользователя, так что это отражает пользователя, который фактически выполнил программу.)
Имеется другой способ, которым Вы могли бы проверить доступ, который является простым для описания, но очень интенсивно используемым. Нужно исследовать биты mode файла и подражать вычислению доступа системы. Этот метод нежелателен, потому что много систем имеют дополнительные возможности управления доступом; ваша программа не может корректно подражать им. Использование access просто и автоматически делает то, что соответствует системе, которую Вы используете.
Символы в этом разделе объявлены в ' unistd.h '.
int access (const char *filename, int how) (функция)
Эта функция использует ID пользователя и группы процесса, а не эффективный ID, для проверки права доступа. В результате, если Вы используете функцию из программы setuid или setgid (см. Раздел 25.4 [Как Изменить Права]), это дает информацию относительно пользователя, кто фактически выполнил программу.
Возвращаемое значение - 0, если доступ разрешается, и -1 иначе. (Другими словами, обрабатываемая как функция предиката, access возвращает истину, если запрошенный доступ отклонен.)
В дополнение к обычным синтаксическим ошибкам имени файла (см. Раздел 6.2.3 [Ошибки Имени файла]), следующие errno условия ошибки определены для этой функции:
доступ, заданный how, отклонен.
файл не существует.
Право записи было запрошено для файла в файловой системе только для чтения.
int R_OK (макрос)
int W_OK (макрос)
int X_OK (макрос)
int F_OK Macro
Каждый файл имеет три временных метки, связанные с ним: время доступа, время изменения, и время изменения атрибута. Они соответствуют st_atime, st_mtime, и st_ctime элементам структуры stat; см. Раздел 9.8 [Атрибуты Файла].
Все эти времена представляются в календарном формате времени, как объекты time_t. Этот тип данных определен в 'time.h'. Для получения более подробной информации и манипулирования значениями времени см. Раздел 17.2 [Календарное Время].
Когда существующий файл открыт, его атрибуты, такие как время изменения, модифицируются. Чтение из файла модифицирует атрибут времени доступа, а запись модифицирует время изменения.
Когда файл создан, все три временных метки для этого файла установлены на текущее время. Кроме того, атрибут времени изменения каталога, который содержит новый вход, модифицируются.
Добавление нового имени для файла с функцией связи модифицирует атрибут поля времени изменения связываемого файла, и соответствующие атрибуты каталога, содержащего новое имя. Те же самые поля изменяются если имя файла удалено с unlink, remove, или rmdir. Переименование файла с rename воздействует только на атрибут времени изменения и изменения поля времени двух родительских включающих каталогов, а не на времена переименовываемого файла.
Изменение атрибутов файла (например, с chmod) модифицирует атрибут времени изменения.
Вы можете также изменять некоторые из временных меток файла, явно используются utime, за исключением изменения атрибута времени изменения. Вы должны включить заглавный файл 'utime.h' чтобы использовать это средство.
struct utimbuf (тип данных)
time_t actime
time_t modtime
int utime (const char *filename, const struct utimbuf *times) (функция)
Если times являются пустым указателем, то время доступа и изменения файла устанавливаются на текущее время. Иначе, они устанавливаются как значения из actime и modtime элементов (соответственно) структуры utimbuf, указанной times. Utime функция возвращает 0 если обращение успешно и -1 при отказе. В дополнение к обычным синтаксическим ошибкам имени файла, следующие errno условия ошибки определены для этой функции:
имеется проблема права в случае, где пустой указатель был передан как аргумент времена. Чтобы модифицировать временную метку на файле, Вы должны также быть владельцем файла и иметь право записи в файл, или быть привилегированным пользователем.
файл не существует.
Если аргумент times - не пустой указатель, Вы должны также быть владельцем файла или привилегированным пользователем.
Файл живет в файловой системе только для чтения.
Utimes функция - подобна utime, но также позволяет Вам определять дробную часть времен файла.
Прототип для этой функции находится в файле 'sys/time.h'.
int utimes (const char *filename, struct timeval tvp[2]) (функция)
Новый время доступа определено tvp [0], а новое время изменения tvp [1]. Эта функция происходит из BSD.
Возвращаемые значения и условия ошибки - такие же как для utime функции.
Mknod функция - примитив для создания специальных файлов, типа файлов, которые соответствуют устройствам. Библиотека GNU включает эту функцию для совместимости с BSD.
Прототип для mknod объявлен в 'sys/stat.h'.
int mknod (const char *filename, int mode, int dev) (функция)
Dev аргумент определяет, к которому устройству обращается специальный файл. Точная интерпретация зависит от вида создаваемого специального файла.
Возвращаемое значение - 0 при успехе и -1 при ошибке. В дополнение к обычным синтаксическим ошибкам имени файла (см. Раздел 6.2.3 [Ошибки Имени Файла]), следующие errno условия ошибки определены для этой функции:
Процесс вызова не привилегирован. Только суперпользователь может создавать специальные файлы.
каталог или файловая система, которая содержала бы, новый файл 'полна' и не может быть расширена.
Каталог, содержащий новый файл не может изменяться, потому что он находится в файловой системе только для чтения.
уже имеется файл, именованный filename. Если Вы хотите заменить этот файл, Вы должны сначала удалить старый файл.
Если Вы должны использовать временный файл в вашей программе, Вы можете использовать tmpfile функцию для его открытия. Или Вы можете использовать tmpnam функцию, что бы сделать имя для временного файла и тогда открыть его обычным способом через fopen. Tempnam функция - подобна tmpnam, но допускает выбирать в какой каталог войдут временные файлы, и кое-что относительно того, на что их имена будут походить.
Эти средства объявлены в заглавном файле 'stdio.h'.
FILE * tmpfile (void) (функция)
char * tmpnam (char *result) (функция)
Возможно tmpnam будет терпеть неудачу, если Вы вызываете ее слишком много раз. Потому что фиксированная длина временного имени файла дает участок памяти для только конечного числа различных имен. Если tmpnam сбоит, она возвращает пустой указатель.
int L_tmpnam (макрос)
int TMP_MAX (макрос)
С библиотекой GNU, Вы можете создавать очень большое количество временных имен файла, если Вы фактически создаете файлы, возможно дисковое пространство закончится прежде, чем закончатся имена. Некоторые другие системы имеют фиксированное, малое ограничение числа временных файлов. Ограничение никогда не меньше чем 25. char * tempnam (const char *dir, const char *prefix) (функция)
Эта функция генерирует уникальное временное имя файла. Если prefix не пустой указатель, то до пяти символов этой строки используется как prefix для имени файла. Prefix каталога для временного имени файла определяется проверкой следующей последовательности. Каталог должен существовать и быть перезаписываемым.
char * P_tmpdir (SVID макрос)
Более старые системы UNIX не имели таких функций. Взамен они использовали mktemp и mkstemp. Обе из этих функций работают изменяя строку шаблона имени файла, заданную Вами. Последние шесть символов этой строки должны быть ' XXXXXX '. Эти шесть X-ов заменятся на шесть символов, которые делают целую строку уникальным именем файла. Обычно строка шаблона - это что-нибудь вроде ' /tmp/prefixXXXXXX ', и каждая программа использует уникальный prefix.
Обратите внимание: Т. к. mktemp и mkstemp изменяют строку шаблона, Вы не должны передать строковые константы им. Строковые константы - обычно в памяти только для чтения, так что ваша программа разрушилась бы, если бы mktemp или mkstemp пробовали изменять строку.
char * mktemp (char *template) (функция)
int mkstemp (char *template) (функция)
В отличие от mktemp, mkstemp, как гарантируют, создаст уникальный файл, который не может сталкиваться с любой другой программой, пробующей создать временный файл. Потому что она работает, вызывая open с O_EXCL битом флага, который говорит, что Вы хотите всегда создавать новый файл, и получать ошибку, если файл уже существует.
Канал - механизм для связи между процессами; данные, записывающиеся в канал одним процессом могут читаться другим процессом. Данные обрабатываются в порядке 'первым пришел' - 'первым ушел' (FIFO). Канал не имеет никакого имени; он создан для одного использования, и оба конца должны быть унаследованы от одиночного процесса, который создал канал.
FIFO специальный файл является подобным каналу, но вместо анонимного, временного соединения, FIFO имеет имя или имена подобно любому другому файлу. Процесс открывает FIFO по имени, чтобы связаться через него.
Канал или FIFO должен быть открыт с обоих концов одновременно. Если Вы читаете из канала или файла FIFO, в который никто ничего не пишет (возможно потому что, они все закрыли файл, или вышли), то чтение возвращает конец файла. Запись в канал или FIFO, который не имеет процесс считывания, обрабатывается как условие ошибки; это генерирует сигнал SIGPIPE, и сбои с кодом ошибки EPIPE, если сигнал обработан или блокируется.
Ни каналы ни FIFO специальные файлы не позволяют позиционирование файла. И чтение и запись происходит последовательно; чтение из начала файла и запись в конец.
Примитив для создания канала - функция pipe. Она создает оба, и чтения и записи концы канала. Это не очень полезно для одиночного процесса, использовать канал, чтобы разговаривать с собой. В типичном использовании, процесс создает канал только прежде, чем он ветвится на один или более дочерних процессов (см. Раздел 23.4 [Создание Процесса]). Канал используется для связи или между родителем или дочерними процессами, или между двумя процессами братьями.
Функция pipe объявлена в заглавном файле 'unistd.h'.
int pipe (int filedes[2]) (функция)
При успехе pipe возвращает значение 0. При отказе, -1. Следующие errno условия ошибки определены для этой функции:
процесс имеет слишком много файлов открытыми.
имеются слишком много открытых файлов во всей системе. См. Раздел 2.2 [Коды Ошибки], для получения более подробной информации о ENFILE.
#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
void
read_from_pipe (int file)
{
FILE *stream;
int c;
stream = fdopen (file, 'r');
while ((c = fgetc (stream)) != EOF)
putchar (c);
fclose (stream);
}
/* Пишем некоторый произвольный текст в канал. */
void
write_to_pipe (int file)
{
FILE *stream;
stream = fdopen (file, 'w');
fprintf (stream, 'hello, world!\n');
fprintf (stream, 'goodbye, world!\n');
fclose (stream);
}
int
main (void)
{
pid_t pid;
int mypipe[2];
/* Create the pipe. */
if (pipe (mypipe))
{
fprintf(stderr,'Pipe failed.\n');
return EXIT_FAILURE;
}
/* Создаем дочерний процесс. */
pid = fork ();
if (pid == (pid_t) 0)
{
/* Это - дочерний процесс. */
read_from_pipe (mypipe[0]);
return EXIT_SUCCESS;
}
else if (pid < (pid_t) 0)
{
/* The fork failed. */
fprintf(stderr,'Fork failed.\n');
return EXIT_FAILURE;
}
else
{
/* Это - родительский процесс. */
write_to_pipe (mypipe[1]);
return EXIT_SUCCESS;
}
}
Общее использование каналов должно послать данные к или получать данные из программы, выполняемой как подпроцесс.
Один из способов выполнения этого - использовать комбинацию pipe (чтобы создать канал), fork (чтобы создать подпроцесс), dup2 (чтобы вынудить подпроцесс использовать pipe как стандартный ввод или канал вывода), и exec (чтобы выполнить новую программу). Или, Вы можете использовать popen и pclose.
Преимущество использования popen и pclose - в том, что интерфейс является намного более простым и более удобным для использования. Но они не предлагают так много гибкости, как использование функций низкого уровня непосредственно.
FILE * popen (const char *command, const char *mode) (функция)
Однако, вместо того, чтобы ждать завершения команды, она создает канал к подпроцессу и возвращает поток, который соответствует этому каналу.
Если Вы определяете аргумент режима 'r', Вы можете читать из потока, чтобы отыскать данные из канала стандартного вывода подпроцесса. Подпроцесс наследует канал стандартного ввода из родительского процесса.
Аналогично, если Вы определяете аргумент режима 'w', Вы можете писать в поток, чтобы посылать данные на канал стандартного ввода подпроцесса. Подпроцесс наследует канал стандартного вывода из родительского процесса.
В случае ошибки, popen возвращает пустой указатель. Это может случаться, если канал или поток не может быть создан, если подпроцесс не может быть раздвоен, или если программа не может быть выполнена.
int pclose (FILE *stream) (функция)
Вот пример, показывающий, как использовать popen и pclose, чтобы фильтровать вывод через другую программу.
#include <stdio.h>
#include <stdlib.h>
void
write_data (FILE * stream)
{
int i;
for (i = 0; i < 100; i++)
fprintf (stream, '%d\n', i);
if (ferror (stream))
{
fprintf (stderr, 'Output to
stream failed.\n');
exit (EXIT_FAILURE);
}
}
int
main (void)
{
FILE *output;
output = popen ('more', 'w');
if (!output)
{
fprintf(stderr,'Could not run
more.\n');
return EXIT_FAILURE;
}
write_data (output);
pclose (output);
return EXIT_SUCCESS;
}
FIFO специальный файл подобен каналу, за исключением того, что он создан различным способом. Вместо анонимного канала связи, FIFO специальный файл введен в файловую систему, вызовом mkfifo.
Если Вы создали FIFO специальный файл таким образом,, любой процесс может открывать его для чтения или записи, таким же образом как обычный файл. Однако, он должен быть открыт в оба конца одновременно прежде, чем Вы можете делать любой ввод или вывод на нем. Открытие FIFO для чтения обычно блокируется, пока некоторый другой процесс не открывает тот же самый FIFO для записи, и наоборот.
Mkfifo функция объявлена в заглавном файле 'sys/stat.h'.
int mkfifo (const char *filename, mode_t mode) (функция)
Нормальное, успешное возвращаемое значение из mkfifo - 0. В случае ошибки возвращается -1. В дополнение к обычным синтаксическим ошибкам имени файла следующие errno условия ошибки определены для этой функции:
именованный файл уже существует.
каталог или файловая система не может быть расширен.
каталог, который содержал бы файл постоянно находится в файловой системе только для чтения.
Чтение или запись данных в канал мгновенны, если размер данных меньше чем PIPE_BUF. Это означает что передача данных кажется мгновенной, в этом случае ничто в системе не может наблюдать состояние, в котором он является частично полным. Быстрый ввод - вывод не может начинаться сразу же (может требоваться ждать пространство буфера или для данных), но если только он начинается, то он заканчивается немедленно.
Чтение или запись большего количества данных может не быть быстрым; например, выходные данные из других процессов, совместно использующих дескриптор могут быть разбиты на части.
См. Раздел 27.6 [Ограничения для Файлов], для уточнения информации относительно параметра PIPE_BUF.
Эта глава описывает средства GNU для межпроцессорной связи, используя гнезда.
Гнездо - обобщенный межпроцессорный канал связи. Подобно каналу, гнездо представляется как дескриптор файла. Но, в отличие от каналов, гнезда поддерживает ссылка между несвязанными процессами, и даже между процессами, выполняющимися на различных машинах, которые связываются по сети. Гнезда - первичный способ связи с другими машинами; telnet, rlogin, ftp, переговоры, и другие сетевые программы используют гнезда.
Не все операционные системы поддерживают гнезда. В библиотеке GNU, заглавный файл 'sys/socket.h' существует независимо от операционной системы, и функции гнезд всегда существуют, но если система действительно не поддерживает гнезда, эти функции всегда терпят неудачу.
Незавершенность: Мы в настоящее время не описали средства для передачи сообщений или для конфигурирования интерфейса Internet.
Когда Вы создаете гнездо, Вы должны определить стиль связи, который Вы хотите использовать и тип протокола, который должен поддерживать ее. Стиль связи гнезда определяет семантику пользовательского уровня посылки и получения данных через гнезда. Выбор стиля связи определяет ответы на вопросы типа:
В заключение Вы должны выбрать протокол, чтобы установить связь. Протокол определяет какой механизм низкого уровня используется, чтобы передавать и получить данные. Каждый протокол допустим для определенного именного пространства и стиля связи; именное пространство иногда называется совокупностью протоколов из-за этого имена именных пространств начинаются с 'PF_'.
Правила протокола относятся к данным, передающимся между двумя программами, возможно на различных компьютерах; большинство этих правил обработано операционной системой, и Вы не нужно знать о них. Вот что Вы должны знать относительно протоколов:
Библиотека GNU поддерживает различные виды сокетов. В этом разделе описываются различные типы сокетов предоставляемые в бибилотекой GNU. Упомянутые в данном разделе символические константы определены в "sys/socket.h".
int SOCK_STREAM (макрос)
Более подробное описание работы с использованием этого типа Вы найдете в Разделе 11.8 [Соединения].
int SOCK_DGRAM (макрос)
Каждый раз когда Вы пишите данные в сокет этого типа, данные становятся одним пакетом. Вы должны определить адрес получателя для каждого пакета.
Единственной гарантией, которую предоставляет Вам система относительно запросов передачи данных, является то, что она пробует наилучшим образом посылать каждый пакет. У нее может получится посылка шестого пакета после неудачи с четвертыми и пятыми пакетами; седьмой пакет может прибыть перед шестым, также второй может прибыть как раз после шестого.
Типичное использование типа SOCK_DGRAM в ситуациях, где есть возможность повторной посылки пакетов, если ответ не был получен в приемлемое время.
int SOCK_RAW (макрос)
Имя сокета обычно называется адресом. Функции и символы для имеющихся адресов сокетов могли называться как с использованием термина, так и использованием термина "адрес". Вы можете расценивать эти термины как синонимичные в контексте обсуждения сокетов.
Сокет, созданный при помощи функции socket, не имеет никакого адреса. Другие процессы могут использовать его для связи только после того как Вы дадите ему адрес. Мы называем это - связывание адреса с сокетом. Связывание происходит при помощи функции bind.
В первый раз, когда Вы посылаете данные из сокета, или используете его, чтобы инициализировать соединение, система назначает адрес автоматически.
Подробности адресации сокетов изменяются, в зависимости от именного пространства, которое Вы используете. См. Раздел 11.4 [Именное пространство Файла], или Раздел 11.5 [Именное пространство Internet].
Независимо от именного пространства, Вы используете те же самые функции bind и getsockname, чтобы установить и исследовать адрес гнезда.
Функции bind и getsockname используют обобщенный тип данных struct sockaddr *, чтобы представить указатель на адрес гнезда. Вы не можете использовать этот тип данных действительно, чтобы интерпретировать адрес или создавать его; для этого, Вы должны использовать соответствующий тип данных для именного пространства гнезда.
Таким образом, обычная нужно создать адрес в соответствующем именном пространстве специфического типа, и приводить указатель на struct sockaddr *, когда Вы вызываете bind или getsockname.
Единственная информация, которую Вы можете получить из структуры sockaddr - указатель формата адреса, который сообщает Вам какой тип данных использовать, чтобы понять адрес полностью.
Символы в этом разделе определены в заголовочном файле "sys/socket.h".
struct sockaddr (тип данных)
short int sa_family
сhar sa_data [14]
Каждый формат адреса имеет символическое имя, которое начинается с "AF_ ". Каждый из них соответствует "PF_ " символу, который обозначает соответствующее именное пространство. Вот список названий форматов адресов:
Обозначает формат адреса, который идет с именным пространством файла. (PF_FILE - имя этого именного пространства.) См. Раздел 11.4.2 [Подробности Именного пространства Файла], для уточнения информации относительно этого формата адреса.
Это синоним AF_FILE, для совместимости. (PF_UNIX аналогично синоним для PF_FILE.)
Обозначает формат адреса, который идет в именном пространстве Internet. (PF_INET - имя этого именного пространства.) См. Раздел 11.5.1 [Формат Адреса Internet].
Не обозначает никакой специфический формат адреса. Он используется только в редких случаях, когда необходимо очистить снаружи заданный по умолчанию адрес адресата от "соединенного" датаграмного сокета. См. Раздел 11.9.1 [Посылка Датаграмм].
"Sys/socket.h" определяет символы, начинающиеся с " AF_ " для различных видов сетей, большинство из которых фактически не встречается. Мы будем документировать только то, что действительно используется на практике.
Используйте функцию bind, чтобы для связывания адреса сокета. Прототип для bind находится в заголовочном файле "sys/socket.h". Для примеров использования см. Раздел 11.4 [Именное пространство Файла].
int bind (int socket, struct sockaddr *addr, size_t length) (функция)
Возвращаемое значение - 0 при успехе и -1 при отказе. Для этой функции в переменной errno определены следующие виды ошибок:
аргумент - не допустимый описатель файла.
дескриптор socket - сокет.
заданный адрес не доступен на этой машине.
Существует другой сокет использующий заданный адрес.
сокет уже имеет адрес.
Вам не достаточно прав для обращения к запрошенному адресу. (В области Internet, только супер-пользователю позволяют определить номер порта в диапазоне от 0 до IPPORT_RESERVED минус один; см. Раздел 11.5.3 [Порты].) Дополнительные условия могут быть возможны в зависимости от специфического именного пространства сокета.
Используйте функцию getsockname, чтобы исследовать адрес гнезда Internet. Прототип для этой функции находится в заголовочном файле "sys/socket.h".
int getsockname (int socket, struct sockaddr *addr, size_t *length_ptr) (функция)
Формат данных адреса зависит от именного пространства сокета. Длина информации обычно устанавливается для данного именного пространства, так что обычно Вы можете знать точно, сколько места необходимо. Обычно нужно зарезервировать место для значения, используя соответствующий тип данных для именного пространства сокета, и тогда привести адрес к struct sockaddr *, чтобы передать его getsockname.
Возвращаемое значение - 0 при успехе и -1 при ошибке. Для этой функции в переменной errno определены следующие виды ошибок:
аргумент socket - не допустимый описатель файла.
дескриптор socket - не сокет.
не имеется достаточных внутренних буферов, доступных для операции.
Вы не можете читать адрес сокета в именном пространстве файла. Это непротиворечиво с остальной частью системы; вообще, не существует способа найти имя файла из описателя для этого файла.
Этот раздел описывает подробности именного пространства файла, чье символическое имя (требуется, когда Вы создаете сокет) PF_FILE.
В именном пространстве файла, адреса сокетов - имена файлов. Вы можете определять любое желаемое имя файла для адреса сокета, но Вы должны иметь право записи в каталоге, содержащем его. Для чтобы соединяться с сокетом, Вы должны иметь право чтения для него. Обычно эти файлы помещаются в каталог `/tmp'.
Одна особенность именного пространства файла -- имя используется только при открытии соединения; если только оно было законченно, адрес не значим и может не существовать.
Другая особенность заключается в том, что Вы не можете соединяться с таким сокетом на другой машине, даже если другая машина совместно использует файловую систему, которая содержит имя это имя сокета. Вы можете видеть сокет в распечатке каталога, но соединение с ним никогда не произойдет.
После того, как Вы закрываете сокет в именном пространстве файла, Вы должны удалить имя файла из файловой системы. Используйте unlink или remove, чтобы делать это; см. Раздел 9.5 [Удаление Файлов].
Именное пространство файла поддерживает только один протокол для любого типа связи; 0 - номер протокола.
Чтобы создавать сокет в именном пространстве файла, используйте константу PF_FILE как аргумент именного пространства для socket или socketpair. Эта константа определена в "sys/socket.h".
int PF_FILE (макрос)
int PF_UNIX (макрос)
Структура для определения имен сокетов в именном пространстве файла определена в заголовочном файле "sys/un.h":
struct sockaddr_un (тип данных)
short int sun_family
char sun_path[108]
Незавершенность: Почему - 108? RMS предлагает делать его массивом нулевой длины и использовать alloc, чтобы зарезервировать соответствующее количество памяти, основываясь на длине filename.
Вы должны вычислить параметр длины для адреса сокета в именном пространстве файла как сумму размера компоненты sun_family и длины (не размера резервирования!) строки имени файла.
Вот пример, показывающий, как создавать и связывать сокет в именном пространстве файла.
#include <stddef.h>
#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <sys/un.h>
int
make_named_socket (const char *filename)
{
struct sockaddr_un name;
int sock;
size_t size;
sock = socket (PF_UNIX, SOCK_DGRAM, 0);
if (sock < 0)
{
perror ("socket");
exit (EXIT_FAILURE);
}
name.sun_family = AF_FILE;
strcpy (name.sun_path, filename);
size=(offsetof(struct sockaddr_un, sun_path)
+ strlen (name.sun_path) + 1);
if (bind (sock, (struct sockaddr *) &name,
size) < 0) {
perror ("bind");
exit (EXIT_FAILURE);
}
return sock;
}
Этот раздел описывает подробности протокола и соглашений именования сокетов, используемые в именном пространстве Internet.
Чтобы создать сокет в именном пространстве Internet, используйте символическое имя PF_INET этого именного пространства как аргумент именного пространства socket или socketpair. Эта макрокоманда определена в "sys/socket.h".
int PF_INET (макрос)
Адрес сокета для именного пространства Internet включает следующие компоненты:
В именном пространстве Internet, адрес состоит из главного адреса и порта на этой главной ЭВМ. Кроме того, протокол, который Вы выбираете, служит как бы частью адреса, потому что местные числа порта значимы только внутри специфического протокола.
Тип данных для представления адресов в именном пространстве Internet определен в заголовочном файле "netinet/in.h".
struct sockaddr_in (тип данных)
short int sin_family
struct in_addr sin_addr
unsigned short int sin_port
Когда Вы вызываете bind или getsockname, Вы должны определить sizeof (struct sockaddr_in) как параметр длины при использовании адреса в именном пространстве Internet.
Каждый компьютер в Internet имеет один, или большое количество Internet адресов, т. е. числа, которые идентифицируют этот компьютер среди остальных на Internet. Пользователи обычно записывают число-адрес главной ЭВМ как последовательность из четырех чисел, отделяемых точками, например "128.52.46.32".
Каждый компьютер также имеет одно или большое количество главных имен, которые являются строками слов, отделяемых точками, например "churchy.gnu.ai.mit.edu".
Программы, которые допускают пользователю определять главную ЭВМ обычно принимают и числовые адреса и главные имена. Но для открытия соединения программе необходим числовой адрес, так что для использования главного имени, Вам нужно преобразовать его в числовой адрес.
Адрес главной ЭВМ в Internet - это номер, содержащий четыре байта данных. Они разделены на две части, сетевой номер и местный номер внутри этой сети. Сетевой номер состоит из первых одного, двух или трех байт; остальная часть байтов - местный адрес.
Сетевые числа зарегистрированы в Сетевом Информационном Центре (NIC), и разделены на три класса A, B, и C. Местные числа сетевого адреса индивидуальных машин зарегистрированы администратором в локальной сети.
Сеть класса А имеет одиночно-байтовые числа в диапазоне от 0 до 127. Сетей класса A не так уж много, но каждая из них может поддерживать очень большое количество главных ЭВМ. Сети класса В размера имеет Двух-байтовые сетевые числа, с первым байтом в диапазоне от 128 до 191. Класс C самый маленький; адреса в нем они имеют Трех-байтовые сетевые числа, с первым байтом в диапазоне 192-255. Таким образом, первый 1, 2, или 3 байты адреса Internet определяют сеть. Оставшиеся байты адреса Internet определяют адрес внутри этой сети.
Нулевая сеть класса A зарезервирована для передачи по всем сетям. Кроме того, главный номер 0 внутри каждой сети зарезервирован для передачи на все главные ЭВМ в этой сети.
127-ая сеть класса A зарезервирована для возврата цикла; Вы можете всегда использовать адрес Internet "127.0.0.1", чтобы обратиться к главной машине.
Так как одиночная машина может быть элементом нескольких сетей, она может иметь много адресов главной ЭВМ Internet. Однако, предполагается, что существует не более одной машины с тем же самым главным адресом.
Имеются четыре формы стандартного расположения чисел и точек для Internet адреса:
Адреса главной ЭВМ Internet представляются в некоторых контекстах как integers (long unsigned int). В других контекстах, integer упакован внутри структуры типа struct in_addr. Было бы лучше, если бы использование было сделано непротиворечивым.
Следующие базисные определения для Internet адреса, появляются в файле "netinet/in.h":
struct in_addr (тип данных)
unsigned long int INADDR_LOOPBACK (макрос)
unsigned long int INADDR_ANY (макрос)
unsigned long int INADDR_BROADCAST (макрос)
unsigned long int INADDR_NONE (макрос)
Это дополнительные функции для управления Internet адресацией, объявленые в "arpa/inet.h". Они представляют Internet адреса в сетевом порядке байтов; это сетевые числа и числа локальных сетевых адресов в главном порядке байтов. См. Раздел 11.5.5 [Порядок Байтов], для объяснения сетевого и главного порядка байтов.
int inet_aton (const char *name, struct in_addr *addr) (функция)
unsigned long int inet_addr (const char *name) (функция)
unsigned long int inet_network (const char *name) (функция)
char * inet_ntoa (struct in_addr addr) (функция)
struct in_addr inet_makeaddr (int net, int local) (функция)
int inet_lnaof (struct in_addr addr)
int inet_netof (struct in_addr addr) (функция)
Кроме стандарта числа-и-точки для Internet адреса, Вы можете также обратиться к главной ЭВМ символическим именем. Преимущество символического имени - то, что его обычно проще запомнить. Например, машина с адресом "128.52.46.32" также может иметь адрес "churchy.gnu.ai.mit.edu"; и другие машины в этом домене могут обратиться к ней просто как "churchy".
Система использует базу данных, чтобы следить за отображением между главными именами и главными числами. Эта база данных - файл, обычно "/etc/hosts" или эквивалент, обеспеченный блоком преобразования имен. Функции и другие символы для доступа к этой базе данных объявлены в "netdb.h". Возможности BSD могут использоваться при подключении файла "netdb.h".
struct hostent (тип данных)
char *h_name
char **h_aliases
int h_addrtype
int h_length
char **h_addr_list
char *h_addr
В главной базе данных каждый адрес только блок памяти h_length байт длиной. Но в других контекстах имеется неявное предположение, что Вы можете преобразовывать его в struct addr_in или long unsigned int. Главные адреса в структуре struct hostent всегда даны в сетевом порядке байтов; см. Раздел 11.5.5 [Порядок Байт].
Вы можете использовать gethostbyname или gethostbyaddr, для уточнения инфрмации базы данных главных ЭВМ относительно специфической главной ЭВМ. Информация возвращена в статически размещенной структуре.
struct hostent * gethostbyname (const char *name) (функция)
struct hostent * gethostbyaddr (const char *addr, int length, (функция)
Если происходит сбой поиска, gethostbyaddr возвращает пустой указатель.
Если поиск имени gethostbyname или gethostbyaddr окончился неудачно, Вы можете выяснить причину, рассматривая значение переменной h_errno. (Было бы правильнее установить errno, но использование h_errno совместимо с другими системами.) Перед использованием h_errno, Вы должны объявить его примерно так:
extern int h_errno;
HOST_NOT_FOUND
TRY_AGAIN
NO_RECOVERY
NO_ADDRESS
Вы можете также просматривать всю базу данных главных ЭВМ используя sethostent, gethostent, и endhostent. Будьте внимательны при использовании этих функций, потому что они не допускают повторного использования.
void sethostent (int stayopen) (функция)
Если аргумент stayopen является отличным от нуля, она устанавливает флаг так, чтобы последующие обращения к gethostbyname или gethostbyaddr не закрыли базу данных (что они обычно сделали бы).
Это делается для эффективности, если Вы вызываете эти функции несколько раз, то избегаете повторного открытия базы данных для каждого обращения.
struct hostent * gethostent () (функция)
void endhostent () (функция)
Адрес сокета в именном пространстве Internet состоит из адреса Internet машины плюс номер порта, который отличает гнездо на данной машине (для данного протокола). Номера портов располагаются от 0 до 65535.
Номера портов меньше, зарезервированых IPPORT_RESERVED для стандартных серверов, типа finger и telnet. Имеется база данных, которая следит за ними, и Вы можете использовать функцию getservbyname для отображения сервисного номера порта; см. Раздел 11.5.4 [База данных Услуг].
Если Вы собираетесь устанавливать сервер, который не является стандартно определенным в базе данных, то Вам необходимо выбрать для него номер порта. Используйте номера большие чем IPPORT_USERRESERVED; такие числа зарезервированы для серверов и никогда не будут генерироваться системой.
Когда Вы используете сокет без определения адреса, система генерирует номер порта для него. Этот номер попадает в интервал между IPPORT_RESERVED и IPPORT_USERRESERVED.
На Internet, фактически, законно иметь два различных сокета с одинаковыми номерами портов, пока они оба не попытаются связаться с тем этим адресом сокета (главный адрес плюс номер порта). Вы не должны дублировать номер порта за исключением специальных обстоятельств, где протокол с более высоким уровнем требует этого. Обычно, система не будет разрешать Вам делать это; bind требует различные номера портов. Чтобы многократно использовать номер порта, Вы должны установить опцию сокета SO_REUSEADDR. См. Раздел 11.11.2 [Опции Сокетов].
Эти макрокоманды определены в заголовочном файле "netinet/in.h".
int IPPORT_RESERVED (макрос)
int IPPORT_USERRESERVED (макрос)
База данных, которая следит за "общеизвестными" услугами - это обычно или файл "/etc/services" или эквивалент из блока преобразования имен. Вы можете использовать эти утилиты, объявленные в "netdb.h" для обращения к базе данных услуг.
struct servent (тип данных)
char *s_name
char **s_aliases
Пустой указатель завершает массив.
int s_port
char *s_proto
Чтобы получать информацию относительно специфического обслуживания, используйте функции getservbyname или getservbyport функции. Информация возвращается в статически размещенной структуре.
struct servent * getservbyname (const char *name, const char *proto) (функция)
Эта функция полезна как для серверов так и для клиентов; серверы используют ее, чтобы определить, на каком порту они должны принимать пакеты (см. Раздел 11.8.2 [Прием]).
struct servent * getservbyport (int port, const char *proto) (функция)
Вы можете также просматривать базу данных услуг, используя setservent, getservent, и endservent. Будьте внимательным в использовании этих функций, потому что они не предназначены для повторного использования.
void setservent (int stayopen) (функция)
Если аргумент stayopen является отличным от нуля, она устанавливает флаг так, чтобы последующие обращения к getservbyname или getservbyport не закрыли базу данных (поскольку они обычно закрыли бы). Это делается для большей эффективности, если Вы вызываете эти функции несколько раз, избегая повторного открытия базы данных для каждого обращения.
struct servent * getservent (void) (функция)
void endservent (void) (функция)
Различные виды компьютеров используют различные соглашения для упорядочения байтов внутри слова. Некоторые компьютеры помещают старший байт сначала (это называется "big-endian" порядком), а другие помещают его последним ("little-endian" порядок).
Так, чтобы машины с различными соглашениями порядка байтов могли связываться, протоколы Internet определяют каноническое соглашение порядка байтов для данных, переданных по сети. Оно известно как сетевой порядок байта.
При установлении соединения в Internet, Вы должны удостовериться, что данные в sin_port и sin_addr элементах структуры sockaddr_in представляются в сетевом порядке байта. Если Вы кодируете данные integer в сообщениях, посланных через сокет, Вы должны преобразовать их в сетевой порядок байта. Если Вы не делаете этого, ваша программа может работать не правильно при сообщении с другими типами машин.
Если Вы используете getservbyname и gethostbyname или inet_addr, для получения номера порта и главного адреса, то эти значения уже в сетевом порядке байта, и Вы можете копировать их непосредственно в структуру sockaddr_in.
Иначе, Вы должны преобразовать значения явно. Используйте htons и ntohs, чтобы преобразовать значения для sin_port элемента. Используйте htonl и ntohl, чтобы преобразовать значения для sin_addr элемента. (Помните, struct in_addr эквивалентен long unsigned int.) Эти функции описаны в "netinet/in.h".
unsigned short int htons (unsigned short int hostshort) (функция)
unsigned short int ntohs (unsigned short int netshort) (функция)
unsigned long int htonl (unsigned long int hostlong)
unsigned long int ntohl (unsigned long int netlong) (функция)
Протокол связи используется для управления низкого уровня обмена данными. Например, протокол осуществляет вещи подобно контрольным суммам, чтобы обнаружить ошибки в передачах, и команды маршрутизации для сообщений.
Заданный по умолчанию протокол связи для именного пространства Internet зависит от стиля связи. Для потокового взаимодействия, значение по умолчанию - TCP ("протокол управления передачей"). Для датаграмной связи, значение по умолчанию - UDP ("протокол датаграммы пользователя"). Для надежной датаграмной связи значение по умолчанию - RDP ("надежный датаграмный протокол"). Вы должны почти всегда использовать это значение по умолчанию.
Протоколы Internet вообще определены именем вместо номера. Сетевые протоколы, которые знает главная ЭВМ, сохранены в базе данных. Она обычно происходит от файла "/etc/protocols", или может быть эквивалент, обеспеченный блоком преобразования имен. Вы можете искать номер протокола, связанный с именованным протоколом в базе данных, используя getprotobyname функцию.
Имеются детализированные описания утилит для доступа к базе данных протоколов. Они объявлены в "netdb.h".
struct protoent (тип данных)
char *p_name
char **p_aliases
Последний элемент массива - пустой указатель.
int p_proto
Вы можете использовать getprotobyname и getprotobynumber, чтобы искать в базе данных протоколов специфический протокол. Информация возвращается в статически размещенной структуре; Вы должны копировать информацию, если Вы хотите сохранить ее для следующих обращений.
struct protoent * getprotobyname (const char *name) (функция)
struct protoent * getprotobynumber (int protocol) (функция)
Вы можете также просматривать целую базу данных протоколов (по одному протоколу одновременно), используя setprotoent, getprotoent, и endprotoent. Будьте внимательным в использовании этих функций, потому что они не предназначены для повторного использования.
void setprotoent (int stayopen) (функция)
Если аргумент stayopen является отличным от нуля, она устанавливает флаг так, чтобы последующие обращения к getprotobyname или getprotobynumber не закрыли базу данных. Это делается для большей эффективности, если Вы вызываете эти функции несколько раз, избегая повторного открытия базы данных для каждого обращения.
struct protoent * getprotoent (void) (функция)
void endprotoent (void) (функция)
Вот пример, показывающий, как создавать и называть сокет в именном пространстве Internet. Созданный сокет существует на машине, на которой выполняется программа. Вместо поиска и использования адреса Internet машины, этот пример определяет INADDR_ANY как главный адрес.
#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <netinet/in.h>
int
make_socket (unsigned short int port)
{
int sock;
struct sockaddr_in name;
sock = socket (PF_INET, SOCK_STREAM, 0);
if (sock < 0)
{
perror ("socket");
exit (EXIT_FAILURE);
}
name.sin_family = AF_INET;
name.sin_port = htons (port);
name.sin_addr.s_addr = htonl (INADDR_ANY);
if (bind (sock, (struct sockaddr *) &name,
sizeof (name)) < 0)
{
perror ("bind");
exit (EXIT_FAILURE);
}
return sock;
}
#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
void
init_sockaddr (struct sockaddr_in *name, const
char *hostname, unsigned short int port)
{
struct hostent *hostinfo;
name->sin_family = AF_INET;
name->sin_port = htons (port);
hostinfo = gethostbyname (hostname);
if (hostinfo == NULL)
{
fprintf (stderr, "Unknown host
%s.\n", hostname);
exit (EXIT_FAILURE);
}
name->sin_addr = *(struct in_addr *)
hostinfo->h_addr;
}
Конечно другие именные пространства и связанные семейства протоколов также реализованы, но не описаны здесь, потому что они редко используются. PF_NS обращается к протоколам Программного обеспечения Сети Ксерокса (Xerox Network Software). PF_ISO замещает Открытые системы Связи (Open Systems Interconnect). PF_CCITT обращается к протоколам из МККТТ (CCITT). "Socket.h" определяет эти символы и другие протоколы.
PF_IMPLINK используется для связи между главными ЭВМ и Процессорами Сообщений Internet.
Этот раздел описывает фактические библиотечные функции для открытия и закрытия сокетов. Те же самые функции работают для всех именных пространств и стилей соединения.
Примитив для создания сокета - функция socket, объявлена в "sys/socket.h".
int socket (int namespace, int style, int protocol) (функция)
Возвращаемое значение из socket - описатель файла для нового сокета, или -1 в случае ошибки. Следующие errno условия ошибки определены для этой функции:
Протокол или стиль не обеспечивается заданным именным пространством.
система имеет слишком много открытыми описателей файла
процесс не имеет привилегии, чтобы создать сокет заданного стиля или протокола.
в системе закончилось внутреннее пространство буфера.
Пример вызова функции socket см. Раздел 11.4 [Именное пространство Файла].
Когда Вы закончили использование сокета, Вы можете просто закрыть описатель файла примитивом close; см. Раздел 8.1 [Открытие и Закрытие Файлов].
Вы можете также выключать только прием или только передачу на соединении, вызывая shutdown, которая объявлена в "sys/socket.h".
int shutdown (int socket, int how) (функция)
0 Остановка при получения данных для этого сокета.
1 Остановка при передаче данных с этого сокета.
2 Остановка и приема и передачи.
socket - не допустимый описатель файла.
socket - не сокет.
socket не соединен.
Пара socket состоит из пары соединенных (но неименованных) сокетов. Это очень похоже на трубопровод и используется аналогичным способом. Пары сокетов создаются функцией socketpair, описание в файле "sys/socket.h".
int socketpair (int namespace, int style, int protocol, int fields[Function2])
Аргументы namespace, style и protocol интерпретируется как в функции socket. style должен быть один из стилей связи, перечисленных в Разделе 11.2 [Стили связb]. Аргумент именного пространства определяет именное пространство, которое должно быть AF_FILE (см. Раздел 11.4 [Именное пространство Файла]); protocol определяет протокол связи.
Если style определяет стиль связи без установки логического соединения, то два сокета, которые Вы получаете, не соединены, строго говоря, но каждое из них знает другое как заданный по умолчанию адрес адресата, так что они могут посылать пакеты друг другу.
Функция Socketpair возвращает 0 при успехе и -1 при отказе. В переменной errno определяются следующие коды ошибок для этой функции:
Процесс имеет слишком много открытых описателей файла.
Не обеспечивается заданное именное пространство.
Не обеспечивается заданный протокол.
Заданный протокол не поддерживает создание пар сокетов.
Наиболее общие стили связи включают создание соединения с другим сокетом, и многократным обменом данными между этими сокетами. Создание соединения асимметрично; одна сторона (клиент) действует, чтобы запросить соединение, в то время как другая сторона (сервер) создает сокет и ждет запрос на соединение.
В создании соединения, клиент делает соединение, в то время как сервер ждет и принимает соединение. Здесь мы обсуждаем то, что клиентская программа должна делать, используя функцию connect, которая объявлена в "sys/socket.h".
int connect (int socket, struct sockaddr *addr, size_t length) (функция)
Обычно, connect ждет, пока сервер не отвечает на запрос прежде. Вы можете устанавливать режим неблокирования на сокете socket, чтобы заставить connect возвратиться немедленно без ожидания ответа. См. Раздел 8.10 [Флаги Состояния Файла], для уточнения инфрмации относительно неблокирования.
Нормальное возвращаемое значение connect - 0. Если происходит ошибка, connect возвращает -1. В переменной errno определяются следующие коды ошибок для этой функции:
сокет socket - не допустимый описатель файла.
указанный сокет - не сокет.
заданный адрес не доступен на отдаленной машине.
именное пространство addr не обеспечивается этим сокетом.
указанный сокет уже соединен.
попытка установить соединение не состоялась.
сервер активно отказался устанавливать соединение.
сеть данного addr не доступна с этой главной ЭВМ.
адрес сокета для данного addr уже используется.
указанный сокет не-блокируемый, и соединение не могло бы быть установлено немедленно.
указанный сокет не-блокируемый и уже имеет отложенное соединение.
Теперь рассмотрим то, что процесс сервера должен делать, чтобы принять соединение из сокета. Это включает использование функции listen, чтобы дать возможность запросам на соединения через сокет, и позже использование функции accept (см. Раздел 11.8.3 [Принятие Соединений] ) чтобы действовать по запросу. Функция listen используется только для уже установленного логического соединения.
В именном пространстве Internet, не сущестует специальных механизмов защиты управления доступом к порту; любой процесс на любой машине может установить соединение с вашим сервером. Если Вы хотите ограничивать доступ к вашему серверу, заставьте его исследовать адреса, связанные с запросами соединения или выполнять некоторое другое подтверждение связи или протокол идентификации.
В именном пространстве Файла, обычные биты защиты файла управляют доступом к сокету.
int listen (int socket, unsigned int n) (функция)
Аргумент n определяет длину очереди для отложенных соединений.
Функция listen возвращает 0 при успехе и -1 в случае неудачи. В переменной errno определяются следующие коды ошибок для этой функции:
аргумент socket - не допустимый описатель файла.
аргумент socket - не сокет.
указанный сокет не поддерживает эту операцию.
Когда сервер получает запрос соединения, он может создать соединение, принимая запрос. Для этих целей следует использовать функцию accept.
Сокет, который был установлен как сервер, может принимать запросы соединения от многих клиентов. Этот сокет сервера не станет частью соединения; взамен, accept делает новый сокет, который разделяет соединения. Accept возвращает описатель для этого сокета.
Исходный сокет сервера остается доступным для ожидания дальнейших запросов соединения.
Число отложенных запросов соединения на сокете сервера конечно. Если запросы соединения прибывают быстрее, чем сервер может их обработать, очередь может заполниться, и дополнительные запросы получат отказ с ошибкой ECONNREFUSED. Вы можете определять максимальную длину этой очереди как аргумент функции listen, хотя система может также наложить собственное внутреннее ограничение длины этой очереди.
int accept (int socket, struct sockaddr *addr, size_t *length_ptr)
Функция accept находится в состоянии ожидания, когда нет возможности принять соединение, если, конечно, указанный сокет не имеет набор режимов неблокирования. (Вы можете использовать select, чтобы ждать отложенное соединение на неблокируемом сокете.) См. Раздел 8.10 [Флаги Состояния Файла], для уточнения информации относительно режима неблокирования.
Аргументы Addr и length_ptr используется, чтобы возвратить информацию относительно имени клиентского сокета, которое инициализировало соединение. См. Раздел 11.3 [Адреса сокетов], для уточнения информации относительно формата.
Сокет, который был установлен как сервер не станет частью соединения; взамен, accept сделает новый сокет. Accept возвращает описатель для этого сокета. Нормальное возвращаемое значение accept - описатель файла для нового сокета.
После accept, первоначально указанный сокет остается открытым и не связанным, и продолжает ожидать, пока Вы не закрываете его. Вы можете принимать дальнейшие соединения с этим сокетом, вызывая accept снова.
Если происходит ошибка, и accept возвращает -1. В переменной errno определяются следующие коды ошибок для этой функции:
аргумент socket - не допустимый описатель файла.
дескрипторный аргумент socket - не сокет.
описанный сокет не поддерживает эту операцию.
сокет имеет набор режимов неблокирования, и нет никаких отложенных соединений.
int getpeername (int socket, struct sockaddr *addr, size_t *length_ptr) (функция)
См. Раздел 11.3 [Адреса Сокетов] , для уточнения информации относительно формата адреса. В некоторых операционных системах, getpeername работает только для сокетов в области Internet.
Возвращаемое значение - 0 при успехе и -1 в случае неудачи. В переменной errno определяются следующие коды ошибок для этой функции:
аргумент socket - не допустимый описатель файла.
указанный сокет - не сокет.
указанный сокет не соединен.
нет внутренних доступных буферов.
Если сокет был соединен с равным, Вы можете использовать обычные примитивы read и write (см. Раздел 8.2[Примитивы ввода - вывода]), чтобы передать данные. Сокет - канал двусторонней связеи, так что чтение и запись может выполняться в оба конца.
Имеются также некоторые режимы ввода - вывода, которые являются специфическими для операций с сокетами. Чтобы определять эти режимы, Вы должны использовать функции recv и send вместо более обобщенного чтения и записи. Функции recv и send берут дополнительный аргумент, который Вы можете использовать, чтобы определить различные флаги, для управления специальными режимами ввода - вывода. Например, Вы можете определить флаг MSG_OOB, чтобы читать или писать внепоточные данные, а также флаги MSG_PEEK или MSG_DONTROUTE.
Функция send объявлена в файле "sys/socket.h". Если ваш аргумент flags нуль, Вы можете точно также использовать write вместо send. Если сокет был соединен, но соединение прервано, Вы получаете сигнал SIGPIPE для каждого использования send или write (см. Раздел 21.2.6 [Разнообразные Сигналы]).
int send (int socket, void *buffer, size_t size, int flags) (функция)
Эта функция возвращает число переданных байтов, или -1 в противном случае. Если сокет неблокируемый, то send (подобно write) может возвращать после посылки только часть данных. См. Раздел 8.10 [Флаги Состояния Файла], для уточнения информации относительно режима неблокирования.
Обратите внимание, что успешное возвращаемое значение просто указывает, что сообщение было послано без ошибки, и не обязательно, что оно было получено без ошибки. В переменной errno определяются следующие коды ошибок для этой функции:
аргумент socket - не допустимый описатель файла.
операция был прервана сигналом прежде, чем любые данные были посланы. См. Раздел 21.5 [Прерванные Примитивы].
указанный сокет - не сокет.
тип сокетаа требует, чтобы сообщение было послано быстро, но сообщение слишком большое для этого.
на сокете был установле режим неблокирования, а операция записи блокирует. (Обычно send блокирует, пока операция не может быть завершена.)
не имеется достаточного внутреннего доступного пространства буфера.
Вы не соединили этот сокет.
Этот сокет был соединен, но соединение теперь разбито. В этом случае send генерирует SIGPIPE сначала; если этот сигнал игнорируется или блокируется, или если обработчик возвращается, то происходит сбой send с EPIPE.
Функция recv объявлена в файле "sys/socket.h". Если ваш аргумент flags является нулем, Вы можете точно также использовать read вместо recv; см. Раздел 8.2 [Примитивы ввода-вывода].
int recv (int socket, void *buffer, size_t size, int flags) (функция)
Если режим неблокирования установлен для сокета, и никакие данные не доступны для чтения, recv не ожидает, а сразу возвращает код ошибки. См. Раздел 8.10 [Флаги Состояния Файла], для уточнения информации относительно режима неблокирования.
Эта функция возвращает число полученных байтов, или -1 в противном случае. В переменной errno определяются следующие коды ошибок для этой функции:
аргумент socket - не допустимый описатель файла.
дескриптор socket - не сокет.
Режим неблокирования был установлен на сокете. (Обычно, recv блокирует пока не имеется входа, доступного для чтения.)
операция была прервана сигналом прежде, чем любые данные прочитались. См. Раздел 21.5 [Прерванные Примитивы].
Вы не соединили этот сокет.
Аргумент flags для send и recv - битовая маска. Вы можете объединить значения следующих макрокоманд вместе (через OR), чтобы получить значение для этого аргумента. Все они определены в файле "sys/socket.h".
int MSG_OOB (макрос)
int MSG_PEEK (макрос)
int MSG_DONTROUTE (макрос)
Вот пример программы клиента, которая устанавливает соединение для сокета в пространстве Internet с поточным типом передачи данных. Она не делает ни чего особенно интересного; если она соединилась с сервером, она посылает текстовую строку серверу и выходит.
#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#define PORT 5555
#define MESSAGE "Yow!!! Are we having fun yet?!?"
#define SERVERHOST "churchy.gnu.ai.mit.edu"
void
write_to_server (int filedes)
{
int nbytes;
nbytes=write(filedes,MESSAGE,strlen(MESSAGE)+1);
if (nbytes < 0)
{
perror ("write");
exit (EXIT_FAILURE);
}
}
int
main (void)
{
extern void init_sockaddr(struct sockaddr_in*name,
const char *hostname,
unsigned short int port);
int sock;
struct sockaddr_in servername;
sock = socket (PF_INET, SOCK_STREAM, 0);
if (sock < 0)
{
perror ("socket (client)");
exit (EXIT_FAILURE);
}
init_sockaddr (&servername, SERVERHOST, PORT);
if (0 > connect (sock,
(struct sockaddr *) &servername,
sizeof (servername)))
{
perror ("connect (client)");
exit (EXIT_FAILURE);
}
write_to_server (sock);
close (sock);
exit (EXIT_SUCCESS);
}
Текст программы сервера намного более сложен. Так как мы хотим предоставлять многим клиентам быть соединенными с сервером, но в то же самое время, было бы неправильно ждать ввод от одиночного клиента, просто вызывая read или recv. Взамен, нужно использовать select (см. Раздел 8.6 [Ждущий ввод - вывод] ), чтобы ждать ввод на всех открытых сокетах. Это также позволяет серверу иметь дело с дополнительными запросами соединения.
Этот специфический сервер не делает хоть что-нибудь интересное, если он получил сообщение от клиента, то он закрывает сокет клиента по получению признака конца файла.
Эта программа использует make_socket и init_sockaddr для устанавления адреса сокета; см. раздел 11.5.7 [Inet Пример].
#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#define PORT 5555
#define MAXMSG 512
int
read_from_client (int filedes)
{
char buffer[MAXMSG];
int nbytes;
nbytes = read (filedes,buffer,MAXMSG);
if (nbytes < 0)
{
perror ("read");
exit (EXIT_FAILURE);
}
else if (nbytes == 0)
return -1;
else
{
fprintf (stderr, "Server: got message:
`%s'\n", buffer);
return 0;
}
}
int
main (void)
{
extern int make_socket (unsigned short int port);
int sock;
int status;
fd_set active_fd_set, read_fd_set;
int i;
struct sockaddr_in clientname;
size_t size;
sock = make_socket (PORT);
if (listen (sock, 1) < 0)
{
perror ("listen");
exit (EXIT_FAILURE);
}
FD_ZERO (&active_fd_set);
FD_SET (sock, &active_fd_set);
while (1)
{
if (select (FD_SETSIZE,
&read_fd_set, NULL,
NULL, NULL) < 0)
{
perror ("select");
exit (EXIT_FAILURE);
}
if (FD_ISSET (i, &read_fd_set))
{
if (i == sock)
{
if (accept (sock,
(struct sockaddr *) &clientname, &size) < 0)
{
perror ("accept");
exit (EXIT_FAILURE);
}
fprintf (stderr,
"Server: connect from host %s, port %hd.\n",
inet_ntoa (clientname.sin_addr),
ntohs (clientname.sin_port));
FD_SET (status, &active_fd_set);
}
else
{
if (read_from_client (i)<0)
{
close (i);
FD_CLR (i, &active_fd_set);
}
}
}
}
}
Потоки с соединениями разрешающими данные вне потока имеют приоритет выше, чем обычные данные. Обычно причина для посылки данных вне потока - исключительные условия. Способ послать данные вне потока использует send с флагом MSG_OOB (см. Раздел 11.8.5.1 [Посылка Данных]).
Данные вне потока посылаются с высшим приоритетом, плюс процесс получения не обрабатывает их в обыкновенное очереди, но чтобы читать доступные данные вне потока следует использовать recv с флагом MSG_OOB (см. Раздел 11.8.5.2 [Получение Данных]). Обычные операции чтения не воспринимают данные вне потока; они читают только обычные данные.
Когда сокет находит, что данные вне потока продвигаются, он посылает сигнал SIGURG процессу владельца или группе процессов сокета. Вы можете определять владельца, используя команду F_SETOWN для функции fcntl; см. Раздел 8.12 [Ввод Прерывания]. Вы должны также установить обработчик для этого сигнала, как описано в Главе 21 [Обработка Сигналов], для соответствующего действия типа чтения данных вне потока.
В качестве альтернативы, Вы можете проверять задержать данные вне потока, или ждать данные вне потока, при использовании функции select; она может ждать исключительное условие на гнезде. См. Раздел 8.6 [Ждущий ввод - вывод].
Уведомление о данных вне потока (с SIGURG или с select) обозначает, что данные вне потока находятся в пути; данные не могут фактически прибывать позже. Если Вы пробуете читать данные вне потока прежде, чем они ппребывают, то recv генерирует ошибку с кодом EWOULDBLOCK.
Посылка таких данных автоматически помещает "метку" в потоке обычных данных, показывающую, где в последовательности данных " были бы "данные вне потока. Это полезно, когда значение данных вне потока - " отменяет все посланное до ". Вот, как Вы можете в процессе получения проверять, были ли любые обычные данные посланы перед меткой:
success = ioctl (socket, SIOCATMARK, &result);
int
discard_until_mark (int socket)
{
while (1)
{
char buffer[1024];
int result, success;
success = ioctl (socket, SIOCATMARK,
&result); if (success < 0)
perror ("ioctl");
if (result)
return;
success = read (socket, buffer, sizeof
buffer);
if (success < 0)
perror ("read");
}
}
struct buffer
{
char *buffer;
int size;
struct buffer *next;
};
struct buffer *
read_oob (int socket)
{
struct buffer *tail = 0;
struct buffer *list = 0;
while (1)
{
char *buffer = (char *) xmalloc (1024);
struct buffer *link;
int success;
int result;
success = recv (socket, buffer, sizeof
buffer, MSG_OOB);
if (success >= 0)
{
link->size = success;
link->next = list;
return link;
}
success = ioctl (socket, SIOCATMARK,
&result);
if (success < 0)
perror ("ioctl");
if (result)
{
sleep (1);
continue;
}
success = read (socket, buffer, sizeof
buffer);
if (success < 0)
perror ("read");
{
link->size = success;
if (tail)
tail->next = link;
else
list = link;
tail = link;
}
}
}
Этот раздел описывает, как использовать стили связи, которые не используют соединения (стили SOCK DGRAM и SOCK_RDM). При использовании этих стилей, Вы группируете данные в пакеты, и каждый пакет - независимая связь. Вы определяете адресата для каждого пакета индивидуально.
Датаграмные пакеты подобны письмам: Вы посылаете каждый независимо, с собственным адресом адресата, и они могут прибывать в неправильном порядке или вообще не прибывать.
Функции listen и accept не предназначены для сокетов, использующих стили связи без установки логического соединения.
Нормальный способ посылки данных относительно датаграмного сокета использует функцию sendto, объявленную в "sys/socket.h".
!!! Вы можете вызывать connect на датаграмном сокете, но эта функция определяет заданного по умолчанию адресата для дальнейшей пе редачи данных на сокете. Когда сокет имеет по умолчанию заданного ад ресата, Вы можете использовать send (см. Раздел 11.8.5.1 [Посылка Дан ных] ) или write (см. Раздел 8.2 [Примитивы ввода - вывода] ) для по сылки пакетов. Вы можете отменять заданного по умолчанию адресата, вы зывая connect, и используя формат адреса AF_UNSPEC в аргументе addr. См. Раздел 11.8.1 [Соединение].
int sendto (int socket, void *buffer. size_t size, int flags, sockaddr *addr, size_t length)
Flags интерпретируется также как и в send; см. Раздел 11.8.5.3 [Опции данных сокетов].
Возвращаемое значение и условия ошибок такие же как и для send, но Вы не можете полагаться на систему для обнаружения ошибок и сообщения о них; наиболее общая ошибка состоит в том, что пакет потеряется или не имеется никого в заданном адресе, чтобы получить его, и операционная система на вашей машине обычно не знает этого.
Также возможно, что для одного обращения к sendto она сообщит ошибку из-за проблемы связанной с предыдущим обращением.
Функция recvfrom читает пакет из датаграмного сокета и также сообщает Вам, откуда он был послан. Эта функция объявлена в "sys/socket.h".
int recvfrom (int socket, void *buffer, size_t size, int flags, struct sockaddr *addr, size_t *length_ptr)
Аргумент size определяет максимальное число байтов, которые нужно читать.
Если пакет является больше чем size байт, то, Вы получаете первые size байт пакета, а остальная часть пакета потеряна. Не существует способа прочитать остальную часть пакета. Таким образом, когда Вы используете протокол пакетов, Вы должны всегда знать длину ожидаемого пакета.
Аргументы addr и length_ptr используются для возвращения адреса источника пакета. См. Раздел 11.3 [Адреса сокетов]. Для сокета в области файла, информация адреса не будет значима, так как Вы не можете читать адрес такого сокета (см. Раздел 11.4 [Именное пространство Файла] ). Вы можете определять пустой указатель как аргумент addr, если Вы не заинтересованы в этой информации.
Flags интерпретируется тем же самым способом как recv (см. Раздел 11.8.5.3 [Опции Данных сокета]). Возвращаемое значение и условия ошибки - такие же как для recv.
Вы можете использовать recv (см. Раздел 11.8.5.2 [Получение Данных]) вместо recvfrom, если знаете, что не должны выяснить, кто послал пакет. Даже read, может использоваться, если Вы не хотите определять flags (см. Раздел 8.2 [Примитивы ввода вывода]).
Вот набор примеров программ, которые посылают сообщения используя датаграмный стиль. И клиент и сервер используют функцию make_named_socket, которая была предоставлена в Разделе 11.4 [Именное пространство Файла], для создания и связывания сокетов.
Сначала программа сервера. Очевидно, это не особенно полезная программа, но она показывает общие идеи.
#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <sys/un.h>
#define SERVER "/tmp/serversocket"
#define MAXMSG 512
int
main (void)
{
int sock;
char message[MAXMSG];
struct sockaddr_un name;
size_t size;
int nbytes;
sock = make_named_socket (SERVER);
while (1)
{
size = sizeof (name);
nbytes=recvfrom(sock,message,MAXMSG,0,
(struct sockaddr*) & name,&size);
if (nbytes < 0)
{
perror ("recfrom (server)");
exit (EXIT_FAILURE);
}
fprintf (stderr, "Server: got message:
%s\n", message);
nbytes=sendto(sock,message,nbytes,0,
(struct sockaddr*) & name,size);
if (nbytes < 0)
{
perror ("sendto (server)");
exit (EXIT_FAILURE);
}
}
}
Вот программа клиента, соответствующая серверу выше.
Она посылает датаграмму серверу и ждет ответ. Обратите внимание, что сокету клиента (также как для сервера) в этом примере должно быть дано имя. Так, чтобы сервер мог направлять сообщение обратно клиенту. Так как сокет не имеет никакого связанного состояния соединения, единственый способ, которым сервер может сделать это ссылаясь на имя клиента.
#include <stdio.h>
#include <errno.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <sys/un.h>
#define SERVER "/tmp/serversocket"
#define CLIENT "/tmp/mysocket"
#define MAXMSG 512
#define MESSAGE "Yow!!! Are we having fun yet?!?"
int
main (void)
{
extern int make_named_socket (const
char *name);
int sock;
char message[MAXMSG];
struct sockaddr_un name;
size_t size;
int nbytes;
sock = make_named_socket (CLIENT);
name.sun_family = AF_UNIX;
strcpy (name.sun_path, SERVER);
size = strlen (name.sun_path) + sizeof (name.sun_family);
nbytes = sendto (sock, MESSAGE,
strlen (MESSAGE) + 1, 0, (struct sockaddr *) & name, size);
if (nbytes < 0)
{
perror ("sendto (client)");
exit (EXIT_FAILURE);
}
nbytes =recvfrom(sock,message,MAXMSG,0,NULL,0);
if (nbytes < 0)
{
perror ("recfrom (client)");
exit (EXIT_FAILURE);
}
fprintf (stderr,"Client: got message: %s\n",message);
remove (CLIENT);
close (sock);
}
Мы объяснили выше, как написать программу сервера, которая реализует собственное ожидание. Такой сервер должен уже выполниться для любого соединения с ним.
Другой способ обеспечивать обслуживание портов для Internet состоит в том, чтобы использовать в программе для ожидания демона inetd. Inetd - программа, которая выполняется все время и ждет (используя select) сообщения на заданном наборе портов. Когда она получает сообщение, она принимает соединение (если стиль сокета запрашивает соединение), и тогда запускает дочерний процесс, чтобы выполнить соответствующую программу сервера. Вы определяете порты и их программы в файле "/etc/inetd.conf".
Написание программы сервера, которая будет выполнена inetd очень просто. Каждый раз когда кто-то запрашивает соединение с соответствующим портом, стартует новый процесс сервера. Соединение уже существует в это время; гнездо доступно как описатель стандартного ввода и как описатель стандартного вывода (описатели 0 и 1) в процессе сервера. Так что программа сервера может начинать читать и писать данные сразу же. Часто программа нуждается только в обычных средствах ввода-вывода; фактически, универсальная программа-фильтр, которая не знает ничего относительно сокетов, может работать как сервер потока байтов, запускаемая inetd.
Вы можете также использовать inetd для серверов, которые используют стили связи без установления логического соединения. Для этих серверов, inetd не пробует принять соединение, так как никакое соединение не возможно. Она только начинает программу сервера, которая может читать входящий датаграмный пакет из описателя 0. Программа сервера может обрабатывать один запрос и выходить, или читать большое количество запросов. Вы должны определить, который из этих двух методов использования сервера удобен Вам при конфигурации inetd.
Файл "/etc/inetd.conf " сообщает inetd, какие порты ожидает какой сервер для обработки пакетов. Обычно каждый вход в файле - это строка, но Вы можете разбивать его на много строк, если все, кроме первой строки входа, начинаются с пропуска. Строки, которые начинаются с "*" являются комментариями.
Имеются два стандартных входа в "/etc/inetd.conf":
ftp stream tcp nowait root /libexec/ftpd ftpd
talk dgram udp wait root /libexec/talkd talkd
service style protocol wait username program arguments
style и protocol определяют стиль связи и протокол для использования ожидающего сокета. Стиль должен иметь имя стиля связи, преобразованного в строчные буквы и с удаленным "SOCK_", например, "stream" или "dgram". Протокол должен быть один из протоколов, перечисленных в "/etc/protocols". Типичные имена протокола - "tcp" для соединений потока байтов и "udp" для ненадежных датаграмм.
Поле wait должно быть, или "wait" или "nowait". "wait" используется, если стиль не требует установления логического соединения и обрабатывает многократные запросы. "nowait" используется, когда необходимо,чтобы inetd начинал новый процесс для каждого сообщения, или запроса, который приходит. Если используется соединение, то wait должен быть "nowait".
user - имя пользователя, под которым сервер должен выполняться. Inetd выполняется под пользователя root, так что она может устанавливать ID пользователей дочерних процессов произвольно. Лучше избегать использования "root" для пользователя; но некоторые серверы, типа Telnet и FTP, читают username и пароль самостоятельно. Эти серверы должны быть запущены под пользователя root изначально, так как они могут регистрировать потоки данных передаваемых по сети.
program вместе с аргументами определяет команду, для запуска сервера. Это должно быть абсолютное имя файла, определяющее исполняемый файл для выполнения. Аргументы состоят из любого числа отделенных пробелами слов, которые станут аргументами командной строки программы.
Первое слово в аргументах - нуль, который должен быть именем программы непосредственно (каталоги sans).
Если Вы редактируете "/etc/inetd.conf", то Вы можете указывать необходимость повторного чтения файла для inetd и сообщения нового содержимого, посылая inetd сигнал SIGHUP. Вы будете должны использовать ps, чтобы определить ID процесса inetd, поскольку оно не фиксировано.
Этот раздел описывает, как читать или установить различные опции, которые изменяют поведение сокетов и их основных протоколов связи.
Когда Вы манипулируете опциями сокета, Вы должны определить, к какому уровню они относятся, то есть применяется ли опция к интерфейсу сокета, или к интерфейсу протокола связи низшего уровня.
Имеются функции для исследования и изменения опций сокета. Они объявлены в "sys/socket.h".
int getsockopt (int socket, int level, int optname, void *optval, size_t *optlen_ptr)
Значение опции сохранено в буфере, на который указывает optval. Перед обращением, Вы должны обеспечить в * optlen_ptr размер этого буфера; по возвращении, он содержит число байтов информации, фактически сохраненной в буфере.
Большинство опций интерпретирует буфер optval как одиночное значение int.
Фактически возвращаемое значение getsockopt - 0 при успехе и -1 в случае неудачи. В переменной errno отражены следующие возможные причины:
аргумент socket - не допустимый описатель файла.
дескриптор socket - не сокет.
Optname не имеет смысла для данного уровня.
int setsockopt (int socket, int level, int optname, void *optval, size_t optlen)
Возвращаемое значение и коды ошибки для setsockopt такие же как для getsockopt.
int SOL_SOCKET (константа)
Вот таблица имен опций уровня сокета; все они определены в файле "sys/socket.h".
SO_DEBUG
SO_REUSEADDR
Значение имеет тип int; значение отличное от нуля означает "да".
SO_KEEPALIVE
SO_DONTROUTE
SO_LINGER
struct linger (тип данных)
int l_onoff
int l_linger
SO_BROADCAST
SO_OOBINLINE
SO_SNDBUF
SO_RCVBUF
SO_STYLE
SO_TYPE
SO_ERROR
Много систем приходят с базой данных, которая записывает список сетей, известных разработчику системы. Она обычно сохраняется или в файле "/etc/networks" или в блоке преобразования имен. Эта база данных полезна для маршрутизации программ типа route, но бесполезна для программ, которые просто связываются по сети. Функции предназначенные для обращения к этой базе данных описаны в "netdb.h ".
struct netent (тип данных)
Он имеет следующие элементы:
char *n_name
char **n_aliases
int n_addrtype
unsigned long int n_net
struct netent * getnetbyname (const char *name) (функция)
struct netent * getnetbyaddr (long net, int type) (функция)
getnetbyaddr возвращает пустой указатель в случае отсутствия такой сети.
void setnetent (int stayopen)
Если аргумент stayopen является отличным от нуля, то она устанавливает флаг так, чтобы последующие обращения к getnetbyname или getnetbyaddr не закрыли базу данных. Это делается для большей эффективности, если Вы вызываете эти функции несколько раз, избегая повторного открытия базы данных для каждого обращения.
struct netent * getnetent (void)
void endnetent (void)
Эта глава описывает функции, которые являются специфическими для терминальных устройств. Вы можете использовать эти функции для действий аналогичным выключению входного отображения на экране, установки характеристик строки типа быстродействия строки и управления потоком данных, и изменения символов используемых для обозначения конца файла, редактирования командной строки, посылки сигналов, и подобных функций управления.
Большинство функций в этой главе использует на описатели файлов. См. Главу 8 [ввод-вывод низкого уровня] для получения более подробной информации, чем описатель файла является и как открыть описатель файла для устройства терминала.
Функции, описанные в этой главе работают с файлами, которые соответствуют терминальному устройству. Используя функцию isatty, Вы можете выяснять, связан ли описатель файла с терминалом.
Прототипы и для isatty и ttyname объявлены в файле "unistd.h".
int isatty (int filedes) (функция)
Если описатель файла связан с терминалом, Вы может получать связанное имя файла, используя функцию ttyname. См. также ctermid функцию, описанную в Разделе 24.7.1 [Идентификация Терминала].
char * ttyname (int filedes) (функция)
Многие из функций в этом разделе обращаются к очередям ввода и вывода терминального устройства. Эти очереди определяют форму буферизации внутри ядра, которое независит от буферизации, выполненной потоками ввода-вывода (см. Главу 7 [ввод-вывод на Потоках]).
Входная очередь терминала также иногда упоминается как буфер клавиатуры. Она содержит символы, которые были получены от терминала, но еще не прочитанны ни каким процессом.
Размер входной очереди терминала описан параметрами _POSIX _MAX_INPUT и MAX_INPUT; см. Раздел 27.6 [Ограничения для Файлов]. Если управление потоком данных ввода допускается установкой бита режима ввода IXOFF (см. Раздел 12.4.4 [Входные Режимы]), драйвер терминала передает символы STOP и START на терминал, когда необходимо предохранить очередь от переполнения. Иначе, ввод можно потерять при сликшом быстром поступлении данных с терминала. (Это маловероятно, если Вы печатаете ввод вручную!)
Очередь вывода терминала подобна входной очереди, но для вывода она содержит символы, которые написаны процессами, но еще не передавались на терминал. Если управление потоком данных вывода допускается установкой бита режима ввода IXON (см. Раздел 12.4.4 [Входные Режимы]), то драйвер терминала удовлетворяет условиям символов STOP и STOP, посланных терминалом, чтобы остановиться и перезапустить передачу вывода.
Очистка входной очереди терминала означает отбрасывание любых символов, которые были получены, но еще не прочитаны. Аналогично, очистка очереди вывода терминала означает отбрасывание любых символов, которые написаны, но еще не передавались.
Системы POSIX поддерживают два базисных режима ввода: каноническиий и неканоническиий.
В каноническом входном режиме ввод с терминала обрабатывается построчно, строка оканчивается символом перевода строки ("\n"), символами EOF, или EOL. Ввод не может закончиться, пока вся строка не напечатана пользователем.
В каноническиом входном режиме, операционная система обеспечивает входное редактирование: символы ERASE и KILL интерпретируются особо для выполнения операций редактирования внутри текущей строки текста. См. Раздел 12.4.9.1 [Редактирование Символов].
Константы _POSIX_MAX_CANON и MAX_CANON указывают максимальное число байтов, которые могут появляться в одиночной строке каноническиого ввода. См. Раздел 27.6 [Ограничения для Файлов].
В неканоническиом входном режиме обработки символы не сгруппированы в строки, и ERASE, и KILL не выполняются. Степень детализации, с которой байты читаются в неканоническиом входном режиме, управляется MIN и TIME. См. Раздел 12.4.10 [Неканоническиий Ввод].
Большинство программ использует каноническиий входной режим, потому что это дает пользователю способ редактировать входную строку. Обычной причиной для использования неканонического режима является необходимость программой принимать одиночно-символьные команды или предоставлять собственные средства редактирования.
Выбор каноническиого или неканоническиого ввода управляется флагом ICANON в элементе _lflag в struct termios. См. Раздел 12.4.7 [Автономные режимов].
Этот раздел описывает различные атрибуты терминала, которые управляют вводом и выводом. Функции, структуры данных, и символические константы объявлены в файле " termios.h".
Вся коллекция атрибутов терминала сохранена в структуре типа struct termios. Эта структура используется функциями tcgetattr и tcsetattr, чтобы читать и установливать атрибуты.
struct termios (тип данных)
tcflag_t c_iflag
tcflag_t c_oflag
tcflag_t c_cflag
tcflag_t c_lflag
cc_t c_cc[NCCS]
Структура struct termios также содержит элементы, которые кодируют скорости передачи ввода и вывода, но представление не преднано. См. Раздел 12.4.8 [Быстродействие Строки], для того, как исследовать и сохранять значения быстродействия.
Следующие разделы описывают подробности элементов структуры struct termios.
tcflag_t (тип данных)
cc_t (тип данных)
int NCCS (макрос)
int tcgetattr (int filedes, struct termios *termios_p) (функция)
В случае успеха tcgetattr возвращает 0. Возвращаемое значение -1 указывает ошибку. Следующие условия ошибки errno определены для этой функции:
filedes аргумент - не допустимый описатель файла.
filedes не связан с терминалом.
int tcsetattr (int filedes, int when, const struct termios *termios_p) (функция)
Аргумент when определяет, как поступать с вводом и выводом, уже поставленным в очередь. Это может быть одно из следующих значений:
Делать изменения немедленно.
TCSADRAIN Делать изменения после ожидания, пока весь поставленный в очередь вывод не написан.
Вы должны обычно использовать эту опцию при изменении параметров, которые воздействуют на вывод.
подобен TCSADRAIN, но отбрасывает любой поставленный в очередь ввод.
Это бит флага, который Вы можете добавлять к любому из вышеупомянутых вариантов. Значение должно запретить чередование состояния аппаратных средств терминала. Это BSD расширение; он не имеет никакого эффекта в не-BSD системах.
При успехе tcsetattr возвращает 0. Возвращаемое значение -1 указывает ошибку. Следующие условия ошибки errno определены для этой функции:
filedes аргумент - не допустимый описатель файла.
filedes не связан с терминалом.
или значение аргумента when не допустимо, или ошибка с данными в аргументе termios_p .
Аналогично, если одиночный процесс имеет многократные или дублированные описатели файла для того же самого устройства терминала, замена атрибутов терминала воздействует на ввод и вывод для всех этих описателей файлов.
Когда Вы устанавливаете режимы терминала, Вы должны сначала вызвать tcgetattr, чтобы получить текущие режимы специфического устройства терминала, и изменять только те режимы, в которых Вы действительно заинтересованы. Для сохранения результата испольуйте tcsetattr.
Плохая практика просто инициализировать структуру struct termios для выбранного набора атрибутов и передавать ее непосредственно в tcsetattr. Ваша программа может быть выполнена через годы на системах, которые поддерживают элементы, не зарегистрированные в этом руководстве.
Более того различные терминальные устройства могут требовать различных установок режима. Так что Вы должны избегать слепого копирования атрибутов из одного терминального устройства в другое.
Вот пример того, как устанавливать один флаг (ISTRIP) в структуре struct termios при правильном сохранении всех других данных в структуре:
int
set_istrip (int desc, int value)
{
struct termios settings;
int result;
result = tcgetattr (desc, &settings);
if (result < 0)
{
perror ("error in tcgetattr");
return 0;
}
settings.c_iflag &= ~ISTRIP;
if (value)
settings.c_iflag |= ISTRIP;
result = tcgetattr (desc, &settings);
if (result < 0)
{
perror ("error in tcgetattr");
return;
}
return 1;
}
Этот раздел описывает флаги атрибутов терминала, которые управляют аспектами низкого уровня входной обработки: обработка ошибок контроля четности, сигналы останова, управление потоком данных, символы и RET и LFD.
Все эти флаги - биты в c_iflag элементе структуры struct termios. Элемент - integer, и Вы изменяете флаги, использующие операторами &, | и ^. Не пробуйте определять все значение для c_iflag_instead, изменяйте только специфические флаги и оставляйте остаток нетронутым (см. Раздел 12.4.3 [Режимы Установки]).
INPCK если этот бит установлен, допускается входная проверка контроля четности. Если он не установлен, никакой проверки ошибок четности нет; символы просто передаются к приложению.
Если этот бит установлен, то при ошибки контроля четности ситуация зависит от того, установлены ли биты IGNPAR или PARMRK. Если никакой из этих битов не установлен, байт с ошибкой контроля четности, передается приложению как символ '\0'.
IGNPAR если этот бит установлен, любой байт с ошибкой четности игнорируется. Это полезно только, если также установлен INPCK.
PARMRK если этот бит установлен, входные байты с ошибкой четности или ошибкой синхронизации отмечены при передачи программе. Этот бит значим только, когда INPCK установлен, и IGNPAR не установлен.
Ошибочные байты отмечены двумя предшествующими байтами, 377 и 0. Таким образом, программа фактически читает три байта для одного ошибочного байта, полученного от терминала.
Если допустимый байт имеет значение 0377, и ISTRIP (см. ниже) не установлен, программа может путать его с префиксом, который отмечает ошибку контроля по четности. Так что допустимый байт 0377 передается программе как два байта, 0377 0377.
ISTRIP если этот бит установлен, допустимые входные байты урезаны до семи битов; иначе, все восемь битов доступны для программ.
IGNBRK если этот бит установлен, условия прерывания игнорируются.
Условие прерывания определено в контексте асинхронной последовательной передачи данных как ряд нулевых битов длиннее байта.
BRKINT если этот бит установлен, и IGNBRK не установлен, условие прерывания очищает ввод терминала и очереди вывода и поднимает сигнал SIGINT для группы приоритетного процесса, связанной с терминалом.
Если ни BRKINT ни IGNBRK не установлены, условие прерывания передается приложению как одиночный символ '\0', если PARMRK не установлен, или иначе как последовательность из трех символов "\377", "\0","\0".
IGNCR Если этот бит установлен, символы возврата каретки ("\r") отброшены на вводе. Отбрасывание возврата каретки может быть полезно на терминалах, которые посылают, и возврат каретки и перевод строки при нажатии клавишу RET.
ICRNL Если этот бит установлен, и IGNCR не установлен, символ возврата каретки (" \r ") передается к приложению как символ перевода строки (" \n ").
INLCR Если этот бит установлен, символ перевода строки ("\n") передан к приложению как символ возврата каретки ("\r").
IXOFF Если этот бит установлен, допускается start/stop контроль над вводом. Другими словами, компьютер посылает символы STOP и START по мере необходимости, чтобы предотвратить ввод от прибытия быстрее чем программы его читают. Идея состоит в том, что фактические аппаратные средства терминала, которые генерируют входные данные, отвечают на символ STOP, приостанавливая передачу, а на символ START, продолжая передачу. См. Раздел 12.4.9.4 [Start/Stop Символы].
IXON Если этот бит установлен, допускается start/stop контроль над выводом. Другими словами, если компьютер получает символ STOP, он приостанавливает вывод, пока символ START не получен.
В этом случае, символы STOP и START никогда не переданы прикладной программе. Если этот бит не установлен, то START и STOP, могут читаться как обычные символы. См. Раздел 12.4.9.4 [Start/Stop Символы].
IXANY если этот бит установлен, любой входной символ перезапускает вывод, когда вывод был приостановлен символом STOP. Иначе, только символ START перезапускает вывод.
IMAXBEL если этот бит установлен, то при заполнении буфера ввода терминала посылается символ BEL (код 007) на терминал (звенит звонок).
Этот раздел описывает флаги терминала и поля, которые управляют, как выводимые символы транслируются и дополняются для дисплея. Все они содержатся в c_oflag элементе struct termiosstructure.
C_oflag элемент непосредственно - integer, и Вы изменяете флаги и поля, используюя операторы &, |, и ^. Не пробуйте определять все значения для c_oflag , изменяйте только специфические флаги и оставляйте остаток нетронутым (см. Раздел 12.4.3 [Режимы Установки]).
int OPOST (макрос)
Если этот бит не установлен, символы передаются как есть.
Следующие три бита возможности BSD, и они не имеют никакого эффекта на не-BSD системах. На всех системах, они эффективны только, если OPOST установлен.
int ONLCR (макрос)
int OXTABS (макрос)
int ONOEOT (макрос)
Этот раздел описывает флаги терминала и поля, которые управляют параметрами, обычно связываемыми с асинхронной последовательной передачей данных. Эти флаги могут не иметь смысла для других видов портов терминала (типа псевдо-терминального сетевого соединения). Все они содержатся в элементе c_cflag структуры struct termios.
Элемент с_сflag непосредственно integer, и Вы изменяете флаги и поля, используюя операторы &, |, и ^. Не пробуйте определять все значения для c_cflag взамен, изменяйте только специфические флаги и оставляйте остаток нетронутым (см. Раздел 12.4.3 [Режимы Установки]).
CLOCAL если этот бит установлен, это указывает, что терминал соединен "локально", и что строки состояния модема должны игнорироваться.
Если этот бит не установлен и Вы вызываете open без O_NONBLOCK набора флагов, оpen блокируются, пока соединение модема не установлено.
Если этот бит не установлен, а модем обнаружен, то посылается сигнал SIGHUP группе процесса управления терминала. Обычно, это вызывает завершение процессов; см. Главу 21 [Обработка Сигнала]. Чтение из терминала после разъединения дает условие конца файла, а запиись вызывает ошибку EIO. Для очищения бита устройство терминала должно быть закрыто и вновь открыто.
HUPCL Если этот бит установлен, то использующие это терминальное устройство процессы по окончании или закрытии файла вызовут разъединение с модемом.
CREAD Если этот бит установлен, ввод может читаться из терминала. Иначе, поступающий ввод отбрасывается.
CSTOPB если этот бит установлен, используются два стоповых бита. Иначе, используется только один стоповый бит .
PARENB если этот бит установлен, допускается порождение и обнаружение бита контроля четности. См. Раздел 12.4.4 [Входные Режимы], для уточнения информации о том, как обрабатываются входные ошибки контроля четности .
Если этот бит не установлен, никакой бит контроля четности не добавлен при выводе символов, и входные символы не проверены по четности.
PARODD Этот бит полезен только, если PARENB установлен. Если PARODD установлен, используется проверка на нечетность, иначе используется проверка на четность.
Флаги режима управления также включают поле для числа битов на символ. Вы можете использовать CSIZE макрокоманду как маску, чтобы извлечь значение, примерно так:
settings.c_cflag & CSIZE.
CSIZE Это маска для числа битов на символ.
CS5 Это определяет пять битов на байт.
CS6 Это определяет шесть битов на байт.
CS7 Это определяет семь битов на байт.
CS8 Это определяет восемь битов на байт.
CCTS_OFLOW Если этот бит установлен, он дает возможность управления потоком выводимых данных, основанного на CTS (RS232 протокол).
CRTS_IFLOW
MDMBUF если этот бит установлен, он предоставляет возможность курьерскому управлению потоком выводимых данных.
Этот раздел описывает флаги для элемента c_lflag структуры struct termios. Эти флаги управляют аспектами с более высоким уровнем ввода, чем флаги режимов, описанные в Разделе 12.4.4 [Входные Режимы], типа отображения на экране, сигналов, и выбора каноническиого или неканоническиого ввода.
Элемент с_lflag непосредственно - integer, и Вы изменяете флаги и поля, используюя операторы &, |, и ^. Не пробуйте определять все значения для c_lflag, а изменяйте только специфические флаги и оставляйте остаток нетронутым (см. Раздел 12.4.3 [Режимы Установки]).
ICANON Этот бит, устанавливает канонический режим обработки ввода. Иначе, ввод обработан в неканоническом режиме. См. Раздел 12.3 [Каноническиий или Нет].
ECHO если этот бит установлен, допускается отображение входных символов обратно на терминал.
ECHOE если этот бит установлен, происходит отображение стирания ввода символом ERASE, уничтожается последний символ в текущей строке. Иначе, уничтоженный символ переотображен, чтобы показать что случилось.
Этот бит управляет только поведением дисплея; ICANON бит управляет фактическим распознаванием символа ERASE и стиранием ввода.
ECHOK Этот бит дает возможность специальному отображению символа KILL. Имеются два способа, которыми это может быть выполнено. Лучший способ стирать всю строку. Худший способ перемещение в новую строку после отображения на экране символа KILL.
Если этот бит не установлен, символ KILL отображается, точно как это было бы, если не было символа KILL. Ввод предшестующий символу KILL не отображается.
ECHONL если этот бит установлен, и бит ICANON также установлен, то символ перевода строки ("\n") отображается на экране, даже если бит ECHO не установлен.
ISIG Этот бит управляет распознаванием символов INTR, QUIT, и SUSP. Функции, связанные с этими символами выполняются только, если этот бит установлен.
В каноническиом или неканоническиом входном режиме терминал может не реагировать на интерпретацию этих символов.
IEXTEN Этот бит подобен ISIG, но контролирует определенные реализацией специальные символы. Если он установлен, он мог бы отменять заданное по умолчанию поведение для ICANON и ISIG флагов автономного режима, и IXON и флагов режима ввода IXOFF.
NOFLSH Обычно, символы INTR, QUIT, и SUSP очищают очереди ввода и вывода для терминала. Если этот бит установлен, очереди, не очищаются.
TOSTOP если этот бит установлен, и система поддерживает управление заданиями, то фоновыми процессами генерируются SIGTTOU сигналы, при попытке записи на терминал. См. Раздел 24.4 [Доступ к Терминалу].
Следующие биты представляют собой расширения BSD; библиотека GNU определяет эти символы в любой системе, но использоваться они будут только в системах BSD.
ECHOKE на системах BSD этот бит выбирает между двумя альтернативными способами отображения символа KILL, когда ECHOK установлен. Если ECHOKE установлен, то символ KILL стирает целую экранную строку; иначе, символ KILL перемещается в следующую экранную строку. Установка ECHOKE не производит никакого эффекта, если бит ECHOK не установлен.
ECHOPRT этот бит дает возможность отображать символ ERASE заданным способом.
ECHOCTL если этот бит установлен, управляющие символы отображаются с "^" сопровождаемый соответствующим текстовым символом. Таким образом, control-A отображается на экране как "^A".
ALTWERASE Этот бит определяет сколько символов WERASE должен стереть. Символ WERASE стирает обратно к началу слова.
Если этот бит является неустановлен, то началом слова считается первый символ после символов пробел. Если бит установлен, то начало слова - алфавитно-цифровой символ или подчеркивание после символа, который не является одним из этих.
FLUSHO - бит, который переключается, когда пользователь печатает символ DISCARD. Если этот бит установлен то вывод не производится.
NOKERNINFO Установка этого бита отключает обработку символа STATUS.
PENDIN если бит установлен, то это означает, что имеется строка ввода, которая должна быть перпечатана.
Печать символа REPRINT устанавливает этот бит; бит остается установленным, пока перепечатывание не закончено. См. Раздел 12.4.9.2 [Редактирование в BSD].
Быстродействие строки терминала сообщает компьютеру как быстро читать и писать данные относительно терминала.
Если терминал соединен с реальной последовательной строкой, быстродействие терминала, которое Вы определяете фактически управляет строкой, если она не соответствует собственной концепции терминала относительно быстродействия, связь не работает.
Реальные последовательные порты воспринимают только некоторые стандартные скорости. Специфические аппаратные средства не могут поддерживать все стандартные скорости. При определении нулевой скорости "зависает " соединение телефонного вызова по номеру и выключаются сигналы управления модема.
Если терминал не реальная последовательная строка (например, если это сетевое соединение), то скорость не будет воздействовать на быстродействие передачи данных, но некоторые программы используют ее, чтобы определить количество необходимого дополнения. Самое лучшее определить значение быстродействия строки, которое соответствует фактическому быстродействию фактического терминала, но Вы можете безопасно экспериментировать с различными значениями, чтобы изменить количество дополнения.
Имеются фактически две скорости строки для каждого терминала, один для ввода и один для вывода. Вы можете устанавливать их независимо, но наиболее часто терминалы используют то же самое быстродействие для обоих направлений.
Значения быстродействия сохранены в структуре struct termios, но не пробуйте обращаться к ним в структуре struct termios непосредственно. Взамен, Вы должны использовать следующие функции, чтобы читать и сохранять их:
speed_t cfgetospeed (const struct termios *termios_p) (функция)
speed_t cfgetispeed (const struct termios *termios_p) (функция)
int cfsetospeed (struct termios *termios_p, speed_t speed) (функция)
int cfsetispeed (struct termios *termios_p, speed_t speed) (функция)
int cfsetspeed (struct termios *termios_p, speed_t speed) (функция)
speed_t (тип данных)
Функции cfsetospeed и cfsetispeed выдают ошибки только для значений быстродействия, которые система просто не может обрабатывать. Если Вы определяете значение быстродействия, которое является в основном допустимым, то эти функции выполняются успешно. Но они не проверяют, что специфическое аппаратное устройство может фактически поддерживать заданное быстродействие, они не знают, для которого устройства Вы планируете устанавливать быстродействие. Если Вы используете tcsetattr, чтобы установить быстродействие специфического устройства в значение, которое оно не может обрабатывать, tcsetattr, возвращает -1.
Примечание Переносимости: В библиотеке GNU, функции выше принимают скорости, измеряемые в битах в секунду как ввод, и возвращает значения быстродействия, измеряемые в битах в секунду. Другие библиотеки требуют, чтобы скорости были обозначены специальными кодами. Для POSIX. 1 переносимости, Вы должны использовать один из следующих символов, чтобы представить быстродействие; их точные числовые значения зависят от системы, но каждое имя, имеет фиксированное значение: B110 замещает 110 бит\сек, B300 для 300 бит\сек, и так далее. Нет никакого переносимого способа представить любое быстродействие, но это единственые скорости, которые последовательные строки могут поддерживать.
B0 B50 B75 B110 B134 B150 B200
B300 B600 B1200 B1800 B2400 B4800
B9600 B19200 B38400
int cfmakeraw (struct termios *termios_p) (функция)
termios_p->c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
|INLCR|IGNCR|ICRNL|IXON);
termios_p->c_oflag &= ~OPOST;
termios_p->c_lflag &= ~(ECHO|ECHONL|ICANON|ISIG|IEXTEN);
termios_p->c_cflag &= ~(CSIZE|PARENB);
termios_p->c_cflag |= CS8;
В каноническиом вводе, драйвер терминала распознает ряд специальных символов, которые выполняют различные функции управления. Они включают символ ERASE (обычно DEL) для редактирования ввода, и другие символы редактирования. Символ INTR (обычно C-c) для посылки сигнала SIGINT, и другие сигнальные символы, могут быть доступны либо в каноническиом либо в неканоническиом входном режиме. Все эти символы описаны в этом разделе.
Специфические используемые символы определены в c_cc элементе struct termios структуры. Этот элемент массив; каждый элемент определяет символ для специфической роли. Каждый элемент имеет символическую константу, которая замещает индекс этого элемента например, INTR - индекс элемента, который определяет символ INTR, так что сохранение "=" в termios.c_cc [INTR] определяет "=" как символ INTR.
На некоторых системах Вы можете отключать специфическую специальную символьную функцию, определяя значение _POSIX_VDISABLE. Это значение неравно любому возможному символьному коду. См. Раздел 27.7 [Опции Файлов] для получения более подробной информации, о том как сообщить операционной системе, которую Вы используете, поддержку _POSIX_VDISABLE.
Эти специальные символы активны только в каноническиом входном режиме. См. Раздел 12.3 [Каноническиий или Нет].
int VEOF (макрос)
Символ EOF распознаваем только в каноническиом входном режиме. Он действует как конец строки таким же образом как символ перевода строки, но если символ EOF печатается в начале строки, это заставляет read возвращать нулевой счетчик байтов, указывая конец файла. Символ EOF непосредственно отбрасывается.
Обычно, символ EOF - C-d.
int VEOL (макрос)
Символ EOL распознаваем только в каноническиом входном режиме. Он действует как признак конца строки, точно так же как символ перевода строки. Символ EOL не отбрасывается; он читается как последний символ во входной строке.
Вы не должны использовать символ EOL, чтобы заставить RET закончить строку. Просто установите ICRNL флаг. Фактически, это заданное по умолчанию состояние.
int VERASE
Символ ERASE распознаваем только в каноническиом входном режиме. Когда пользователь печатает символ удаления, предыдущий печатаемый символ отбрасывается. (Если терминал генерирует многобайтовые символьные последовательности, может быть отброшен больше чем один байт ввода.) Символ ERASE непосредственно отбрасывается.
Обычно, символ ERASE - DEL.
int VKILL (макрос)
Символ KILL распознаваем только в каноническиом входном режиме. Когда пользователь печатает этот символ, все содержимое текущей строки ввода отбрасывается. Сам символ непосредственно также отбрасывается.
Символ KILL - обычно C-u.
12.4.9.2 BSD Расширения Редактирующих Символов
int VEOL2 (макрос)
Символ EOL2 работает точно так же как символ EOL (см. выше), но это может быть другой символ. Таким образом, Вы можете определять два символа, чтобы завершить входную строку, устанавливая EOL как один из них и EOL2 как другой.
int VWERASE (макрос)
Символ WERASE распознаваем только в каноническиом входном режиме. Он стирает слово предшествующего ввода.
int VREPRINT (макрос)
Символ REPRINT распознаваем только в каноническом входном режиме. Он перепечатывает текущую входную строку.
int VLNEXT (макрос)
Символ LNEXT распознаваем только, когда IEXTEN установлен. Он отключает редактирующее значение следующего печатающегося символа. Это аналог команды C-q в Emacs.
Символ LNEXT - обычно C-v.
Эти специальные символы могут быть активны или в каноническом или в неканоническом входном режиме, но только, когда флаг ISIG установлен (см. Раздел 12.4.7 [Автономные режимы]).
int VINTR (макрос)
INTR символ (прерывания) вызывает сигнал SIGINT для всех процессов в приоритетной работе, связанной с терминалом. Символ INTR непосредственно отбрасывается. См. Главу 21 [Обработка Сигнала] , для получения более подробной информации.
Обычно, символ INTR - C-c.
int VQUIT (макрос)
Символ QUIT вызывает сигнал SIGQUIT для всех процессов в приоритетной работе, связанной с терминалом. Символ QUIT непосредственно отбрасывается. См. Главу 21 [Обработка Сигнала], дл получения более подробной информации.
Обычно, символ QUIT - C-\.
int VSUSP (макрос)
Termios.c_cc [VSUSP] содержит символ непосредственно.
SUSP (приостанавливающий) символ, распознается только, если реализация поддерживает управление заданиями (см. Главу 24 [Управление заданиями]). Он посылает сигнал SIGTSTP всем процессам в приоритетной работе, связанной с терминалом. Символ SUSP непосредственно отбрасывается. См. Главу 21 [Обработка Сигнала], для получения более подробной информации.
Обычно, символ SUSP - C-z.
Некоторые приложения отключают нормальную интерпретацию символа SUSP. Если ваша программа делает это, она должна обеспечить какой-нибудь другой механизм для пользователя, чтобы остановить работу. Когда пользователь вызывает этот механизм, программа должна послать сигнал SIGTSTP группе процесса, а не только процессу непосредственно. См. Раздел 21.6.2 [Передача сигналов для Другого Процесса].
int VDSUSP (макрос)
DSUSP (приостанавливающий) символ распознается только, если реализация поддерживает управление заданиями (см. Главу 24 [Управление заданиями]). Он посылает сигнал SIGTSTP, подобно символу SUSP, но не сразу, а когда программа пробует читать его как ввод.
Не все системы с управлением заданиями поддерживают DSUSP; только системы BSD. См. Главу 21 [Обработка Сигнала], для получения более подробной информации.
Обычно, символ DSUSP - C-y.
Эти специальные символы могут быть активны или в каноническиом или в неканоническиом входном режиме, но их использование управляется флагами IXON и IXOFF (см. Раздел 12.4.4 [Входные Режимы]).
int VSTART
Символ START используется, чтобы поддерживать режимы ввода IXON и IXOFF. Если IXON установлен, то получение символа START продолжает приостановленный вывод; символ START непосредственно отбрасывается. Если IXOFF установлен, то система может также передавать символы START на терминал.
Обычное значение для символа START - C-q. Вы не можете изменить это значение, т. к. аппаратные средства могут настаивать на использовании C-q независимо от того, что Вы определяете.
int VSTOP (макрос)
Символ STOP используется, чтобы поддерживать IXON и IXOFF режимы ввода. Если IXON установлен, то получение символа STOP заставляет риостановить вывод; символ STOP непосредственно отбрасывается. Если IXOFF установлен, система может также передавать символы STOP на терминал, предохранняя входную очередь от переполнения.
Обычное значение для символа STOP - C-s.
Имеются два дополнительных специальных символа, которые являются значимыми на системах BSD.
int VDISCARD (макрос)
Символ DISCARD распознаваем только, когда установлен IEXTEN . Он должен переключить флаг отбрасывания вывода. Когда этот флаг установлен, весь вывод программы отбрасывается. Установка флага также отбрасывает весь вывод находящийся в настоящее время в буфере вывода.
int VSTATUS (макрос)
Символ STATUS должен распечатать сообщение состояния относительно того, как текущий процесс выполняется.
Символ STATUS распознаваем только в каноническом режиме. Это специфическое решение задачи, так как значение символа STATUS ничего не делает со вводом.
В неканоническом входном режиме, специальные символы редактирования типа ERASE и KILL игнорируются.
Средства системы для редактирования ввода в неканоническиом режиме заблокированы, так, чтобы все входные символы (если они не специальные сигналы и не управляющие потоком данных) были переданы прикладной программе точно как печатались.
Неканоническиий режим предлагает специальные параметры называемые MIN и TIME для управления тем как долго ждать доступного ввода. Вы можете даже использовать их, чтобы избежать ожидания, чтобы возвратиться немедленно с любым вводом, или без ввода.
MIN и TIME сохранены в элементах c_cc массива, который является элементом struct termiosstructure. Каждый элемент этого массива имеет специфическую роль, и каждый элемент имеет символическую константу, которая замещает индекс этого элемента. VMIN и VMAX имена для индексов TIME и MIN.
int VMIN
MIN значим только в неканоническиом входном режиме; он определяет минимальное число байтов, которые должны быть доступны во входной очереди для возвращения read.
int VTIME (макрос)
TIME значим только в неканоническиом входном режиме; он определяет, как долго ждать ввод перед возвращением, в единицах по 0.1 секунды.
Значения MIN и TIME взаимодействуют, чтобы определить критерий для возвращения read; их точные значения зависят, от того какой из них является отличным от нуля. Имеются четыре возможных случая:
O И MIN и TIME - нули.
В этом случае, read всегда возвращается немедленно со столькими символами, сколько доступно в очереди, до запрошенного числа. Если никакой ввод не является немедленно доступным, read возвращает нуль.
O MIN - нуль, но TIME имеет значение отличное от нуля.
В этом случае, read ждет в течение времени TIME доступного ввода; доступность одиночного байта должна быть достаточна, чтобы удовлетворить запрос read. По возвращению функция принимает значение обозначающее количество доступных символов вплоть до запрошенного числа. Если никакой ввод не является доступным в заданное время, read возвращает нуль.
O TIME - нуль, но MIN имеет значение отличное от нуля.
В этом случае, read ждет, пока по крайней мере MIN байтов станут доступны в очереди. И возвращает количество доступных символов. Read может возвращать больше, чем MIN символов.
O И TIME и MIN отличны от нуля.
В этом случае, TIME определяет, как долго ждать следующего ввода после каждого входного символа. Read ждет, пока или MIN байтов прочитаны, или TIME истекает без дальнейшего ввода.
Read может не возвращать никакого ввода, если TIME истекает прежде, чем появится первый входной символ. Read может возвращать больше, чем MIN символов, если в очереди их больше чем MIN.
Что случается, если MIN - 50, и Вы запрашиваете прочитать только 10 байтов? Обычно, read ждет до 50 байтов в буфере (т. е. пока условие ожидания не удовлетварено), и тогда читает 10 из них, оставляя другие 40 буферизированными в операционной системе для последующего обращения read.
Примечание Переносимости: На некоторых системах, места MIN и TIME в массиве фактически такие же как у EOF и EOL. Это не вызывает никакой серьезной проблемы, потому что MIN и TIME используется только в неканоническиом вводе, а EOF и EOL используются только в каноническиом вводе, но это не совсем хорошо. Библиотека GNU резервирует отдельные места для них.
Эти функции выполняют разнообразные управляющие действия на терминальных устройствах. Что касается доступа к терминалу, они обрабатываются подобно выполнению вывода: если любая из этих функций используется фоновым процессом на управляемом терминале, то обычно всем процессам в группе процесса посланы сигналы SIGTTOU. Исключение, если вызывающий процесс непосредственно игнорирует или блокирует сигналы SIGTTOU, тогда операция выполняется, и никакой сигнал не посылается. См. Главу 24 [Управление заданиями].
int tcsendbreak (int filedes, int duration)
Эта функция ничего не делает, если терминал не асинхронный последовательный порт данных.
Возвращаемое значение обычно нуль. В случае ошибки, возвращается значение -1. Следующие условия ошибки errno определены для этой функции:
filedes - не допустимый описатель файла.
filedes не связан с устройством терминала.
int tcdrain (int filedes) (функция)
Возвращаемое значение обычно нуль. В случае ошибки, возвращается значение -1. Следующие условия ошибки errno определены для этой функции:
filedes - не допустимый описатель файла.
filedes не связан с устройством терминала.
операция была прервана сигналом. См. Раздел 21.5 [Прерванные Примитивы].
int tcflush (int filedes, int queue) (функция)
TCIFLUSH очистить любые полученные, но еще не прочитанные, входные данные.
TCOFLUSH очистите любые выходные данные, которые написаны, но еще не переданный.
TCIOFLUSH Очистить, поставленный в очередь и ввод и вывод.
Возвращаемое значение обычно нуль. В случае ошибки, возвращаеися значение -1. Следующие условия ошибки errno определены для этой функции:
filedes - не допустимый описатель файла.
filedes не связан с устройством терминала.
плохое значение было обеспечено как аргумент queue.
int tcflow (int filedes, int action) (функция)
Аргумент action определяет то, какую операцию выполнять, и может быть одним из следующих значений:
TCOOFF Приостанавливают передачу вывода.
TCOON Рестарт передачи вывода.
TCIOFF Передача символа STOP.
TCION Передача символа START.
Возвращаемое значение обычно нуль. В случае ошибки, возвращается значение -1. Следующие условия ошибки errno определены для этой функции:
filedes - не допустимый описатель файла.
filedes не связан с устройством терминала.
плохое значение был обеспечен как аргумент action.
Вот пример программ, который показывает как Вы можете устанавливать устройство терминала для чтения одиночных символов в неканоническиом входном режиме, без ECHO.
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <termios.h>
struct termios saved_attributes;
void
reset_input_mode (void)
{
tcsetattr (STDIN_FILENO, TCSANOW,
&saved_attributes);
}
void
set_input_mode (void)
{
struct termios tattr;
char *name;
if (!isatty (STDIN_FILENO))
{
fprintf (stderr,
"Not a terminal.\n");
exit (EXIT_FAILURE);
}
tcgetattr (STDIN_FILENO, &saved_attributes);
atexit (reset_input_mode);
tcgetattr (STDIN_FILENO, &tattr);
tattr.c_lflag &= ~(ICANON|ECHO);
tattr.c_cc[VMIN] = 1;
tattr.c_cc[VTIME] = 0;
tcsetattr (STDIN_FILENO, TCSAFLUSH, &tattr);
}
int
main (void)
{
char c;
set_input_mode ();
while (1)
{
read (STDIN_FILENO, &c, 1);
if (c == '\004') /* C-d */
break;
else
putchar (c);
}
return EXIT_SUCCESS;
}
Оболочка, как предполагается, заботится о сбросе режимов терминала, когда процесс остановлен или продолжается; см. Главу 24 [Управление заданиями]. Но некоторые существующие оболочки фактически не делают это, так что Вы можете установить обработчики для сигналов управления заданиями, которые сбрасывают режимы терминала. Вышеупомянутый пример делает так.
Эта глава содержит информацию относительно функций для выполнения математических вычислений, типа тригонометрических функций. Большинство этих функций имеет прототипы, объявленные в файле "math.h".
Все функции используют аргументы с плавающей запятой и возвращают результаты типа double. В будущем, могут появиться дополнительные функции, которые используют значения long double и float. Например, cosf и cosl были бы версиями функци cos, которые используют аргументы типов float и long double, соответственно. Вы должны избегать использовать эти имена самостоятельно. См. Раздел 1.3.3 [Зарезервированные Имена].
Многие из функций, перечисленных в этой главе определены математически над областью, которая является только подмножеством вещественных чисел. Например, acos функция определена над областью от -1 до 1. Если Вы передаете аргумент одной из этих функций, который не находится в области, на которой она определена, функция устанавливает errno как EDOM, чтобы указать ошибку области. На машинах, которые поддерживают формат ИИЭР (IEEE) с плавающей запятой, также возвращают ошибку EDOM и NaN.
Некоторые из этих функций определены математически, чтобы привести к комплексному значению над частями их областей. Наиболее знакомый пример это квадратный корень отрицательного числа.
Функции в этой главе берут аргументы только с плавающей точкой и возвращают значения соответственно того же типа.
Проблема возникает тогда, когда математический результат функции не может быть представим как число с плавающей запятой. Если величина результата слишком большая, функция устанавливает errno как ERANGE, чтобы указать ошибку диапазона, и возвращает "очень большое значение" (именованое макрокомандой HUGE_VAL) или отрицание (- HUGE_VAL).
Если величина результата является слишком малой, возвращается нулевое значение. В этом случае, errno может быть или не быть установлена как ERANGE.
Единственый полностью надежный способ проверять ошибки области и диапазона состоит в том, чтобы установить errno как 0 прежде чем Вы вызываете математическую функцию и затем проверять errno. Следствие такого использования errno является то, что математические функции не могут быть многократно использованы с проверкой ошибок.
Ни одна из математических функций не генерирует сигналы в результате ошибок диапазона или области. В частности это означает что Вы не будете видеть сигналы SIGFPE, сгенерированные внутри этих функций. (См. Главу 21 [Обработка Сигнала], для получения более подробной информации.)
double HUGE_VAL (макрос)
Значение этой макрокоманды используется как возвращаемое значение из различных математических функций в случаях переполнения.
Для получения более подробной информации см. Раздел A. 5.3.2 [Параметры с плавающей запятой]. В частности макрокоманда DBL_MAX могла бы быть более удобной, чем HUGE_VAL для многих использований отличных от тестирования ошибки в математической функции.
Это знакомые функции sin, cos, и tan. Аргументы всех этих функций измеряются в радианах; помните, что pi радиан равняются 180 градусам.
Математическая библиотека не определяет символическую константу для pi, но Вы можете определять вашу собственную, если Вы нуждаетесь в этом:
#define PI 3.14159265358979323846264338327
double sin (double x)
double cos (double x)
double tan (double x)
Следующие errno условия ошибки определены для этой функции:
Математически функция tan имеет особенности в точках (2*k+1)*pi/2. Если аргумент x близок к одной из этих особенностей, tan устанавливает errno как ERANGE и возвращает или положительный или отрицательный HUGE_VAL.
Это обычные arcsin, arccos и arctan функции, которые являются обратными для синуса, косинуса и тангенса, соответственно.
double asin (double x)
Asin устанавливает errno как EDOM, если x находится вне диапазона. Функция арксинуса определена математически только над областью от -1 до 1.
double acos (double x)
Acos устанавливает errno как EDOM, если x находится вне диапазона. Функция аркосинуса определена математически только над областью от -1 до 1.
double atan (double x)
Значение результата дается в радианах. Математически, имеется бесконечно много таких значений; но фактически возвращаются значения между -pi/2 и pi/2 (включая).
double atan2 (double y, double x)
Если x и y координаты точки в плоскости, atan2 возвращает угол между линией от начала координат до этой точки и осью X. Таким образом, atan2 полезен для преобразования декартовых координат в полярные координаты. (Чтобы вычислять радиальную координату, используйте hypot; см. Раздел 13.4 [Экспоненты и Логарифмы])
Функция atan2 устанавливает errno как EDOM, если и x и y нули и возвращаемое значение не определено.
double exp (double x)
Если величина результата слишком большая, чтобы быть представимой функция устанавливает errno как ERANGE.
double log (double x)
Следующие условия ошибки errno определены для этой функции:
Функция устанавливает EDOM, если аргумент x отрицателен. Функция log определена математически, чтобы возвращать результат только на положительных аргументах.
Функция устанавливает ERANGE, если аргумент - нуль. Log нуля не определен.
double log10 (double x)
double pow (double base, double power)
Следующие условия ошибки errnoопределены для этой функции:
Функция устанавливает EDOM base, если аргумент отрицателен.
Функция устанавливает ERANGE, если было обнаружено условие переполнения.
double sqrt (double x)
Sqrt устанавливает errno как EDOM, если x отрицателен. Математически, квадратный корень был бы комплексным числом.
double cbrt (double x)
double hypot (double x, double y)
double expm1 (double x)
double log1p (double x)
Функции в этом разделе связаны с экспоненциальными функциями; см. Раздел 13.4 [Экспоненты и Логарифмы].
double sinh (double x) (функция)
double cosh (double x) (функция)
double tanh (double x) (функция)
double asinh (double x) (функция)
double acosh (double x) (функция)
double atanh (double x) (функция)
Этот раздел описывает средства GNU для получения ряда псевдослучайных чисел. Сгенерированные числа не совсем произвольные; обычно, они формируют последовательность, которая повторяется периодически, с периодом настолько большим, что Вы можете игнорировать его для обычных целей. Генератор случайных чисел работает, используя всегда значение начального числа, чтобы вычислить следующее случайное число и так далее.
Хотя сгенерированные чисала выглядят непредсказуемо при одном выполнении программы, последовательность чисел точно та же самая и при следующем выполении. Это происходит, потому что начальное число всегда одно то же . Это удобно, когда Вы отлаживаете программу, но неподходит, если Вы хотите, чтобы программа вела себя непредсказуемо. Если Вы хотите действительно случайные числа, а не только псевдослучайными, определяйте начальное число, основываясь на текущем времени.
Вы можете получать повторяющиеся последовательности чисел на машине определенного типа, определяя то же самое начальное значение начального числа для генератора случайных чисел. Не существует никакого стандарта для значения начального числа; то же самое начальное число, используемое в различных библиотеках C или на различных типах CPU , даст Вам различные случайные числа.
Библиотека GNU поддерживает стандартные функции случайного числа ANSI C плюс набор, который происходит от BSD. Мы рекомендуем, чтобы Вы использовали стандартные rand и srand.
Этот раздел описывает функции случайного числа, которые являются частью стандарта ANSI C.
Чтобы использовать эти средства, Вы должны включить заглавный файл "stdlib.h" в вашей программе.
int RAND_MAX (макрос)
int rand () (функция)
void srand (unsigned int seed) (функция)
Если Вы вызываете rand перед тем как начальное число было установлен srand, то она использует значение 1 как заданное по умолчанию начальное число.
Чтобы производить случайные числа (не только псевдослучайные), делайте srand(time(0)).
Этот раздел описывает набор функций для порождения случайного числа, являющиеся дополнением к BSD.
Нет особого преимущества при использовании этих функций с библиотекой GNU C; мы поддерживаем их только для совместимости BSD.
Прототипы для этих функций находятся в " stdlib.h ".
long int random () (функция)
void srandom (unsigned int seed) (функция)
Чтобы производить действительно случайные числа (не только псевдослучайные), делайте srandom(time(0)).
void * initstate (unsigned int seed, void *state, size_t size) (функция)
Возвращаемое значение - предыдущее значение массива информации о состоянии. Вы можете использовать это значение позже как аргумент setstate, чтобы восстановить состояние.
void *setstate (void *state)
Возвращаемое значение - предыдущее значение массива информации о состоянии. Вы можете использовать это значение позже как аргумент setstate, чтобы восстановить состояние.
Эта глава содержит информацию относительно функций предназначенных для выполнения базисных арифметических операций, типа разбивания float на целую и дробную части. Эти функции объявлены в заголовочном файле "math.h ".
Формат ИИЭР с плавающей запятой используемый наиболее современными компьютерами, поддерживает значения, которые являются "не числами". Эти значения называются NaN. Эти значения следуют из некоторых операций, которые не имеют никакого значимого числового результата, типа нуля, деленого на нуль или бесконечности, деления на бесконечность.
Одна примечательная особенность NaN'ов заключается в том, что они не равны себе. Таким образом, x == x может быть 0, если значение x - NaN. Вы можете использовать это, чтобы проверить является ли значение NaN или нет: если оно не равно себе, то это - NaN. Но рекомендуемый способ проверять NaN - isnan функцией (см. Раздел 14.2 [Предикаты на Значениях с Плаваюшей точкой]).
Почти любая арифметическая операция, в которой аргумент является NaN, возвращает NaN.
double NAN (макрос)
Вы можете использовать " #ifdef NAN " чтобы проверить, поддерживает ли машина NaN. (Конечно, Вы должны принять меры, чтобы расширения GNU были видимыми, определяя _GNU_SOURCE, и Вы должны включить " math.h ".)
Этот раздел описывает некоторые разнообразные функции-тесты double значений. Прототипы для этих функций появляются в "math.h". Это функции BSD, и таким образом доступны, если Вы определяете _BSD_SOURCE или _GNU_SOURCE.
int isinf (double x) (функция)
int isnan (double x) (функция)
int finite (double x) (функция)
double infnan (int error) (функция)
В библиотеке BSD, на некоторых машинах, infnan вызывает фатальный сигнал во всех случаях. Библиотека GNU не делает аналогично, потому что это не удовлетворяет спецификации ANSI C.
Примечание Переносимости: функции, перечисленные в этом разделе - расширения BSD.
Эти функции предусмотрены для получения абсолютного значения (или величины) числа. Абсолютное значение вещественного числа x - x если x положителен, -x, если x отрицателен. Для комплексного числа z, чья вещественная часть является x и чья мнимая часть является y, абсолютное значение - sqrt (x * x + y * y).
Прототипы для abs и labs находятся в " stdlib.h "; fabs и cabs объявлены в " math.h ".
int abs (int number) (функция)
Большинство компьютеров использует двоичное дополнение представления integer, в котором абсолютное значение INT_MIN (самый маленький возможный int) не может представляться; таким образом, abs (INT_MIN) не определен.
long int labs (long int number) (функция)
double fabs (double number) (функция)
double cabs (struct { double real, imag; } z) (функция)
sqrt (z.real*z.real + z.imag*z.imag)
Функциям, описанные в этом разделе прежде всего обеспечивают способ эффективно выполнить некоторые манипулирования низкого уровня на числах с плавающей запятой, которые представляются, внутренне используя двоичную систему счисления. Эти функции требуются, чтобы реализовать эквивалентное поведение, даже если представление не использует основание системы счисления 2, но конечно они, вряд ли, будут особенно эффективны в тех случаях.
Все эти функции объявлены в " math.h ".
double frexp (double value, int *exponent) (функция)
Если значение аргумента value - не нуль, возвращаемое значение value - число степеней двойки, и всегда в диапазоне от 1/2 (включ.) до 1 (исключ.). Соответствующая экспонента сохранена в *exponent; возвращаемое значение, умноженное на 2 возведенное в эту экспоненту, равняется первоначальному значению числа.
Например, frexp (12.8, &exponent) возвращает 0.8 и сохраняет 4 в exponent.
double ldexp (double value, int exponent) (функция)
Например, ldexp (0.8, 4) Возвращает 12.8.
Следующие функции, которые исходят ИЗ BSD, обеспечивают эквиваленты средств ldexp и frexp:
double scalb (double value, int exponent)
double logb (double x)
Когда 2 в этой степени разделена на x, это дает частное между 1 (включ.) и 2 (исключ.).
Если x - нуль, значение - минус бесконечность (если машина поддерживает такое значение), или очень малое число. Если x - бесконечность, значение - бесконечность.
Значение, возвращенное logb на один меньше чем то что frexp сохранил бы в *exponent.
double copysign (double value, double sign) Function
Функции, перечисленные здесь выполняют операции типа округления, усечения, и взятия остаточного члена от деления чисел с плавающей запятой. Некоторые из этих функций преобразовывают числа с плавающей запятой в целочисленные значения. Они все объявлены в " math.h ".
Вы можете также преобразовывать числа с плавающей запятой в integer просто, приводя их к int. Это отбрасывает дробную часть, действительно округляя к нулю. Однако, это работает только, если результат может фактически представляться как int и для очень больших чисел, это невозможно. Функции, перечисленные здесь возвращают результат как double, чтобы обойти эту проблему.
double ceil (double x)
double floor (double x)
double rint (double x)
Режим округления значения по умолчанию к самому близкому целому числу; некоторые машины поддерживают другие режимы, но этот не всегда используется если Вы явно выбираете другой.
double modf (double value, double *integer_part)
Modf сохраняет целочисленную часть в *integer_part, и возвращает дробную часть. Например, modf (2.5, &intpart) возвращает 0.5 и сохраняет 2.0 в integer_part.
double fmod (double numerator, double denominator)
Результат имеет тот же самый знак как numerator и имеет величину меньше чем величина denominator.
Если denominator - нуль, fmod сбоит и устанавливает errno как EDOM.
double drem (double numerator, double denominator) (функция)
Абсолютное значение результата - меньше или равно половине абсолютного значения denominator. Различие между fmod (numerator, denominator) и drem (numerator, denominator) - всегда либо denominator, либо -denominator, либо нуль.
Если denominator - нуль, drem сбоит и устанавливает errno как EDOM.
Этот раздел описывает функции для выполнения деления целых чисул. Эти функции избыточны в библиотеке GNU C, с тех пор в GNU C, оператор ` / ' всегда округляется к нулю. Но в других реализациях C, " / " может поступать по-другому с отрицательными аргументами. div и ldiv полезны, потому что они определяют как округляется частное: к нулю. Остаточный член имеет тот же самый знак как числитель.
Эти функции определены, чтобы возвратить результат r такой, что значение r.quot*denominator+r.rem равняется numerator.
Чтобы использовать эти средства, Вы должны включить заглавный файл " stdlib.h " в вашей программе.
div_t (тип данных)
div_t div (int numerator, int denominator) (функция)
Если результат не может представляться (напр. деление на нуль), поведение не определено.
Вот пример, хотя и не очень полезный.
div_t result;
result = div (20, -6);
ldiv_t (тип данных)
long int quot
long int rem
ldiv_t ldiv (long int numerator, long int denominator) (функция)
Этот раздел описывает функции для "чтения" целого числа и чисел с плавающей запятой из строки. Может быть более удобно в некоторых случаях использовать sscanf или одну из подобных функций; см. раздел 7.11 [Форматируемый Ввод]. Но часто Вы можете делать программу более надежной, находя лексемы в строке вручную, и преобразуя их в числа один за другим.
Эти функции объявлены в " stdlib.h ".
long int strtol (const char *string, char **tailptr, int base) (функция)
Если строка является пустой, содержит только пропуск(и), или не содержит начальную подстроку, которая имеет ожидаемый синтаксис для целого числа с заданным base, никакое преобразование не выполняется. В этом случае, strtol возвращает нулевое значение, а значение, сохраненное в *tailptr - значение строки.
Если строка имеет допустимый синтаксис для целого числа, но значения не представимы из-за переполнения, strtol возвращает или LONG_MAX или LONG_MIN (см. Раздел A. 5.2 [Диапазон Типа]), соответствующее знаку значения. Она также устанавливает errno как ERANGE, чтобы указать, что имелось переполнение.
См. пример в конце этого раздела.
unsigned long int strtoul (const char *string, char **tailptr, int base)
long int atol (const char *string) (функция)
int atoi (const char *string) (функция)
Вот функция, которая анализирует строку как последовательность целых и возвращает их сумму:
int
sum_ints_from_string (char *string)
{
int sum = 0;
while (1) {
char *tail;
int next;
while (isspace (*string)) string++;
if (*string == 0)
break;
errno = 0;
next = strtol (string, &tail, 0);
if (errno)
printf ("Overflow\n");
else
sum += next;
string = tail;
}
return sum;
}
Эти функции объявлены в " stdlib.h ".
double strtod (const char *string, char **tailptr) (функция)
Эта функция пытается разлагать строку следующим образом:
В этом случае, strtod возвращает нуль, а значение, возвращенное в *tailptr - значение строки.
В стандарте отличном от стандарта "C", эта функция может распознавать дополнительный синтаксис.
Если строка имеет допустимый синтаксис для числа с плавающей запятой, но значения, не представимы из-за переполнения, strtod возвращает или положительный или отрицательный HUGE_VAL (см. Главу 13 [Математика]), в зависимости от знака значения. Аналогично, если значение не представимо из-за близости к нулю, strtod возвращает нуль. Она также устанавливает errno как ERANGE, если имелось переполнение или обнуление.
double atof (const char *string) (функция)
Эта глава описывает функции для поиска и сортировки массивов произвольных объектов. Вы определяете соответствующую функцию сравнения, которую нужно применить как аргумент, наряду с размером объектов в массиве и общим числом элементов.
Чтобы использовать библиотечные функции сортировки массива, Вы должны описать, как сравнить элементы массива.
Чтобы сделать это, Вы обеспечиваете функцию сравнения, для сравнения двух элементов массива. Библиотека вызовет эту функцию, передавая как указатели на аргументы два элемента массива, которые нужно сравнить. Ваша функция сравнения должна возвратить значение как strcmp (см. Раздел 5.5 [Сравнение СТРОКИ/МАССИВА]): отрицательное, если первый аргумент - "меньше" чем второй, нуль, если они "равны", и положительное если первый аргумент "больше".
Вот пример функции сравнения, которая работает с массивом чисел типа double:
int
compare_doubles (const double *a, const double *b)
{
return (int) (*a - *b);
}
int comparison_fn_t (const void *, const void *);
Чтобы искать в сортируемом массиве элемент, соответствующий ключу, используйте bsearch функцию. Прототип для этой функции находится в заглавном файле " stdlib.h ".
void * bsearch (const void *key, const void *array, size_t count, size_t size, comparison_fn_t compare)
Возвращаемое значение - указатель на соответствующий элемент массива, или пустой указатель, если никакое соответствие не найдено. Если массив содержит больше чем один подходящий элемент, неопределено который же возвращается.
Эта функция получила имя из предположения, что она выполнена, используя двоичный алгоритм поиска.
Для сортировки массива, используюя произвольную функцию сравнения, используйте qsort функцию. Прототип для этой функции находится в " stdlib.h ".
void qsort (void *array, size_t count, size_t size, comparison_fn_t compare)
Функция compare используется, чтобы выполнить сравнение на элементах массива. Эта функция вызывается с двумя аргументами указателями и должна возвратить целое число меньше , равное, или больше нуля, если первый аргумент меньше , равен, или больше чем второй аргумент.
Предупреждение: если, два объекта сравниваются как равные, их порядок после сортировки, непредсказуем. То есть сортировка не устойчива. Она может делать различие, когда сравнение рассматривает только часть элементов. А также, два элемента с тем же самым ключом сортировки могут отличиться в других отношениях.
Вот простой пример сортировки массива double значений в числовом порядке используя функцию сравнения, определенную выше (см. Раздел 15.1 [Функции Сравнения]):
{
double *array;
int size;
. . .
qsort(array,size,sizeof(double),compare_doubles);
}
Вот пример, показывающий использование qsort и bsearch с массивом структур. Объекты в массиве сортируются, сравнивнением их name полей функцией strcmp.
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
struct critter
{
const char *name;
const char *species;
};
struct critter muppets[] =
{
{"Kermit", "frog"},
{"Piggy", "pig"},
{"Gonzo", "whatever"},
{"Fozzie", "bear"},
{"Sam", "eagle"},
{"Robin", "frog"},
{"Animal", "animal"},
{"Camilla", "chicken"},
{"Sweetums", "monster"},
{"Dr. Strangepork", "pig"},
{"Link Hogthrob", "pig"},
{"Zoot", "human"},
{"Dr. Bunsen Honeydew", "human"},
{"Beaker", "human"},
{"Swedish Chef", "human"}
};
int count=sizeof(muppets)/sizeof(struct critter);
int
critter_cmp (const struct critter *c1,
const struct critter *c2)
{
return strcmp (c1->name, c2->name);
}
void
print_critter (const struct critter *c)
{
printf ("%s, the %s\n", c->name,
c->species);
}
void
find_critter (const char *name)
{
struct critter target, *result;
target.name = name;
result = bsearch (&target, muppets, count,
sizeof (struct critter), critter_cmp);
if (result)
print_critter (result);
else
printf ("Couldn't find %s.\n", name);
}
int
main (void)
{
int i;
for (i = 0; i < count; i++)
print_critter (&muppets[i]);
printf ("\n");
qsort (muppets, count, sizeof (struct
critter), critter_cmp);
for (i = 0; i < count; i++)
print_critter (&muppets[i]);
printf ("\n");
find_critter ("Kermit");
find_critter ("Gonzo");
find_critter ("Janice");
return 0;
}
Kermit, the frog
Piggy, the pig
Gonzo, the whatever
Fozzie, the bear
Sam, the eagle
Robin, the frog
Animal, the animal
Camilla, the chicken
Sweetums, the monster
Dr. Strangepork, the pig
Link Hogthrob, the pig
Zoot, the human
Dr. Bunsen Honeydew, the human
Beaker, the human
Swedish Chef, the human
Animal, the animal
Beaker, the human
Camilla, the chicken
Dr. Bunsen Honeydew, the human
Dr. Strangepork, the pig
Fozzie, the bear
Gonzo, the whatever
Kermit, the frog
Link Hogthrob, the pig
Piggy, the pig
Robin, the frog
Sam, the eagle
Swedish Chef, the human
Sweetums, the monster
Zoot, the human
Kermit, the frog
Gonzo, the whatever
Couldn't find Janice.
Библиотека GNU C обеспечивает средства сопоставления с образцом для двух видов шаблонов: регулярные выражения и универсальные символы имени файла.
Этот раздел описывает, как шаблон универсальных символов соответствует специфической строке. Результат - ответ да или никакого ответа: строка удовлетворяет шаблону или нет. Символы, описанные здесь объявлены в " fnmatch.h ".
int fnmatch (const char *pattern, const char *string, int flags)
Flags - комбинация флаговых битов, которые изменяют подробности соответствия. См. ниже список определенных флагов.
В Библиотеке GNU C, fnmatch не может испытывать "ошибку", она всегда возвращает ответ, преуспевает ли соответствие. Однако, другие реализации fnmatch могут иногда сообщать "ошибки", возвращая значения отличные от нуля, которые не равны FNM_NOMATCH.
Вот доступные флаги для аргумента flags:
FNM_FILE_NAME
FNM_PATHNAME
FNM_PERIOD
Если Вы устанавливаете, и FNM_PERIOD и FNM_FILE_NAME, то "." после "/" трактуется также как к "." в начале строки. (Оболочка использует FNM_PERIOD и FNM_FILE_NAME флаги вместе для соответствия имен файлов.)
FNM_NOESCAPE
Если Вы используете FNM_NOESCAPE, то " \ " является обычным символом.
FNM_LEADING_DIR
Если этот флаг установлен, и " foo* " и " foobar " как шаблоны, соответствуют строке " foobar/frobozz ".
FNM_CASEFOLD
Типичное использование групповых символов - для соответствия файлов в каталоге, и создании списка всех соответствий. Это называется globbing.
Вы могли бы делать это используя fnmatch, читая входы каталога один за другим и проверяя каждый с fnmatch. Но это было бы медлено (и сложно, так как Вы будете должны обработать подкаталоги вручную).
Библиотека обеспечивает функцию glob, чтобы делать это с использованием удобных универсальных символов. Glob и другие символы в этом разделе объявлены в " glob.h ".
Результат globbing - вектор имен файлов. Чтобы возвращать этот вектор, glob использует специальный тип данных, glob _t, который является структурой. Вы передаете glob адрес структуры, и она вносит поля структуры, чтобы сообщить Вам результаты.
glob_t (тип данных)
Gl_pathc Число элементов в векторе.
Gl_pathv Адрес вектора. Это поле имеет тип char **.
Gl_offs Смещение первого реального элемента вектора, от
номинального адреса в gl_pathv поле. В отличие от других полей,
это -- всегда ввод glob, а не вывод из нее (т. е. вы должны
указать его).
Gl_offs поле значимо только, если Вы используете GLOB_DOOFFS флаг.
Иначе, смещение - всегда нуль независимо от того, что находится в этом поле, и первый реальный элемент расположен в начале вектора.
int glob (const char *pattern, int flags, int (*errfunc) (const char *filename, int error-code), glob_t *vector_ptr)
Результат globbing - последовательность имен файлов. Glob резервирует строку для каждого возникающего в результате слова, и вектор типа char **, чтобы сохранить адреса этих строк. Последний элемент вектора - пустой указатель. Этот вектор называется вектором слов.
Чтобы возвратить этот вектор, glob сохраняет и адрес и длину (число элементов, не считая завершающий пустой символа) в *vector_ptr.
Обычно, glob сортирует имена файлов в алфавитном порядке перед их возвращением. Вы можете указать флаг GLOB_NOSORT, если Вы хотите получать информацию, с наибольшей скоростью.
Если glob преуспевает, она возвращает 0. Иначе, она возвращает один из этих кодов ошибки:
GLOB_ABORTED Имелась ошибка открытия каталога, и Вы использовали флаг GLOB_ERR, или ваша заданная errfunc возвратила значение отличное от нуля. См. ниже объяснение GLOB_ERR и errfunc.
GLOB_NOMATCH Шаблон не соответствовал ни каким существующим файлам. Если Вы используете GLOB_NOCHECK флаг, то Вы, никогда не получаете этот код ошибки, потому что этот флаг сообщает, чтобы glob симулировал что шаблону соответствует по крайней мере один файл.
GLOB_NOSPACE Было невозможно зарезервировать память, чтобы содержать результат.
В случае ошибки, glob сохраняет информацию в *vector_ptr относительно всей соответствий, которые она уже нашла.
Этот раздел описывает флаги, которе Вы можете определять в аргументе flags в glob. Выберите флаги которые Вы хотите, и объедите их оператором OR (| в Си).
GLOB_APPEND
Для этого, Вы не должны изменить содержимое структуры вектора слов между обращениями к glob. И, если Вы устанавливаете GLOB_DOOFFS в первом обращении к glob, Вы должны также установить его, когда Вы добавляете.
Обратите внимание, что указатель, сохраненный в gl_pathv может больше не быть допустимым после того, как Вы вызываете glob второй раз, потому что glob может переместить вектор. Так что всегда берите gl_pathv из структуры _t glob после каждого обращения к glob; никогда не сохраните указатель между обращений.
GLOB_DOOFFS
GLOB_ERR
Вы можете осуществлять управление, определяя функцию обработчика ошибки errfunc, когда Вы вызываете glob. Если errfunc - не пустой указатель, то glob не отказывается сразу же, когда она не может читать каталог; взамен, она вызывает errfunc с двумя аргументами, примерно так:
(*errfunc) (filename, error-code)
Если функция обработчика ошибки возвращает не нуль, то glob завершается сразу же. Иначе, она продолжается.
GLOB_MARK Если шаблон соответствует имени каталога, конкатенирует " / " к имени каталога при его возвращении.
GLOB_NOCHECK Если шаблон не соответствует ни каким именам файлов, возвращает шаблон непосредственно, как будто это было имя файла. (Обычно, когда шаблон не соответствует чему - нибудь, glob говорит что не имелось никакого соответствия.)
GLOB_NOSOR(***) Не сортирует имена файлов. (Практически, порядок будет зависеть от порядка входов в каталоге.) Единственая причина не сортировать состоит в том, чтобы сохранить время.
GLOB_NOESCAPE Не обрабатывает символ ` \ ' в шаблонах. Обычно, " \ " цитирует следующий символ, выключая специальное значение так, чтобы он соответствовал только непосредственно символу. Когда цитирование допускается, шаблон " \? " соответствует только строке "? ", потому что вопросительный знак в шаблоне действует подобно обычному символу.
Если Вы используете GLOB_NOESCAPE, то " \ " является обычным символом.
Glob делает это, вызывая функцию fnmatch. Она обрабатывает флаг GLOB_NOESCAPE, включая FNM_NOESCAPE флаг в обращениях к fnmatch.
Библиотека GNU C поддерживает два интерфейса для соответствия регулярных выражений. Один - стандартный POSIX.2 интерфейс, а другой - тот, который система GNU использовала много лет.
Оба интерфейса объявлены в заглавном файле " regex.h ". Если Вы определяете _POSIX_C_SOURCE, то будут объявлены только POSIX.2 функции, структуры, и константы.
Прежде, чем Вы можете фактически использовать регулярное выражение, Вы должны откомпилировать его. Это - не истинная трансляция, это производит специальную структуру данных, а не машинные команды. Но это - подобно обычной трансляции, цель которой дать Вам возможность " выполнить" шаблон быстро. (См. Раздел 16.3.3 [Соответствие POSIX Регулярным Выражениям], для того, как использовать компилируемое регулярное выражение для соответствия.)
Имеется специальный тип данных для компилируемых регулярных выражений:
regex_t (тип данных)
Имеются и другие поля, но мы не описываем их здесь, потому что только функции в библиотеке должны использовать их.
После того, как Вы создаете объект regex_t, Вы можете компилировать регулярное выражение в ней, вызывая regcomp.
int regcomp (regex_t *compiled, const char *pattern, int cflags)
Вам нужно только зарезервировать объект типа regex_t и передать адрес regcomp.
Аргумент cflags допускает Вам, определять различные опции, которые управляют синтаксисом и семантикой регулярных выражений.
Если Вы используете флаг REG_NOSUB, то regcomp, опускает из компилируемого регулярного выражения информацию, необходимую для записи соответствий подвыражений. В этом случае, Вы можете также указывать 0 для matchptr и nmatch аргументов, когда Вы вызываете regexec.
Если Вы не используете REG_NOSUB, то компилируемое регулярное выражение имеет запись соответствия подвыражений. Также, regcomp сообщает Вам, сколько подвыражений имеет шаблон, сохраняя число в compiled->re_nsub. Вы можете использовать это значение, чтобы решить, какую длину массива зарезервировать, чтобы содержать информацию относительно соответствий подвыражений.
Regcomp возвращает 0, если она преуспевает в компилировании регулярного выражения; иначе, она возвращает код ошибки отличный от нуля (см. таблицу ниже). Вы можете использовать regerror, чтобы произвести строку сообщения об ошибках для значений отличных от нуля.
Имеются возможные значения отличные от нуля, которые regcomp может возвращать:
REG_BADBR Имеется недопустимая конструкция " \{. . .\} " в регулярном выражении. Допустимая " \{. . .\} " конструкция должна содержать или одиночное число, или два числа в увеличивающемся порядке, отделенные запятой.
REG_BADPAT Имелась синтаксическая ошибка в регулярном выражении.
REG_BADRPT Оператор повторения типа " ? " или " * " оказался, в плохой позиции (без предшествующего подвыражения).
REG_ECOLLATE Регулярное выражение сносится на недопустимый элемент объединения (не определенный в текущем стандарте для строкового объединения). См. Раздел 19.3 [Категории Стандарта].
REG_ECTYPE Регулярное выражение ссылается на недопустимое символьное имя класса.
REG_EESCAPE Регулярное выражение законченно " \ ".
REG_ESUBREG Имелось недопустимое число в " \digit " конструкции.
REG_EBRACK Имелись несбалансированные квадратные скобки в регулярном выражении.
REG_EPAREN Расширенное регулярное выражение имело незакрытые скобки, или базисное регулярное выражение имело несбалансированные "\(" и "\)".
REG_EBRACE Регулярное выражение имело несбалансированные "\{" и "\}".
REG_ERANGE Одна из оконечных точек в выражении диапазона была недопустима.
REG_ESPACE Regcomp не хватает памяти.
Это - битовые флаги, который Вы можете использовать в cflags операнде при компилировании регулярного выражения с regcomp.
REG_EXTENDED
REG_ICASE
REG_NOSUB
REG_NEWLINE
Иначе, символ перевода строки действует подобно любому другому обычному символу.
Если только Вы компилировали регулярное выражение, как описано в Разделе 16.3.1 [Трансляция POSIX Регулярных выражений], Вы можете применять его к строкам используя regexec. Соответствие где-нибудь внутри строки считается как успех, если регулярное выражение не содержит символы " ^ " или " $ ".
int regexec (regex_t *compiled, char *string, size_t nmatch, regmatch_t matchptr [], int eflags) (функция)
Regexec возвращает 0 если tcnm соответствие выражению; иначе, она возвращает значение отличное от нуля. См. таблицу ниже для того, что означают значения отличные от нуля. Вы можете использовать regerror, чтобы произвести строку сообщения об ошибках для значений отличных от нуля.
Аргумент eflags - слово битовых флагов, которые дают возможность различным опциям.
Если Вы хотите получать информацию относительно части строки которая фактически соответствовала регулярному выражению или подвыражению, используйте аргументы matchptr и nmatch. Иначе, укажите 0 для nmatch, и пустой указатель для matchptr.
Функция regexec принимает следующие флаги в аргументе eflags:
REG_NOTBOL Не расценивает начало заданной строки как начало строки; более вообще, не делает ни каких предположений относительно того, что текст мог бы предшествовать ей.
REG_NOTEOL Не расценивает конец заданной строки как конец строки; более обще, не делает ни каких предположений относительно того, что текст мог бы следовать за ней.
Имеются возможные значения отличные от нуля, которые regexec может возвращать:
Шаблон не соответствовал строке. Это в общем не ошибка.
Когда regexec находит соответствия подвыражениям шаблона, она записывает, которым частям строки они соответствуют. Она возвращает эту информацию, сохраняя смещения в массиве, чьи элементы являются структурами типа regmatch_t. Первый элемент массива (индекс 0) записывает часть строки, которая соответствовала всему регулярному выражению. Каждый другой элемент массива записывает начало и конец части, которая соответствовала одиночному вводному подвыражению.
regmatch_t
regoff_t
Когда Вы вызываете regexec, Вы определяете длину matchptr массива, с nmatch аргументом.
Это сообщает regexec сколько элементов сохранить. Если фактическое регулярное выражение имеет больше чем nmatch подвыражений, то, Вы не будет получать информацию о смещениях относительно остальной их части.
Еслио Вы не хотите, чтобы regexec возвращал любую информацию относительно подвыражений, Вы можете обеспечить 0 для nmatch, или использовать флаг REG_NOSUB, когда Вы компилируете шаблон с regcomp.
Иногда подвыражение соответствует подстроке без символов. Это случается, когда " f\(o*\) " соответствует строке " fum ". (Оно действительно соответствует только " f ".) В этом случае, оба смещения идентифицируют отметку в строке, где была найдена пустая подстрока. В этом примере, оба смещения 1.
Иногда все регулярное выражение может соответствовать без использования некоторых из подвыражений вообще, например, когда " ba\(na\)* " соответствует строке " ba ", вводное подвыражение не используется. Когда это случается, regexec сохраняет -1 в обоих полях элемента для этого подвыражения.
Иногда при соответствии всего регулярного выражения некоторая подстрока может соответствовать специфическому подвыражению больше чем один раз например, когда " ba\(na\)* " соответствует строка " bananana ", вводное подвыражение соответствует три раза. Когда это случается, regexec обычно сохраняет смещения последней части строки, которая соответствовала подвыражению. В случае " bananana ", эти смещения - 6 и 8.
Когда Вы закончили использование компилируемого регулярного выражения, Вы можете освободить память, которую оно использует, вызывая regfree.
void regfree (regex_t *compiled) (функция)
Вы должны всегда освобождать место в структуре regex_t с regfree перед использованием структуры, чтобы компилировать другое регулярное выражение.
Когда regcomp или regexec сообщает об ошибке, Вы можете использовать функцию regerror, преобразовать ее в строку сообщения об ошибках.
size_t regerror (int errcode, regex_t *compiled, char *buffer, size_t length) (функция)
Если сообщение об ошибках не помещается в length байтах (включая пустой символ завершения), то regerror усекает его. Эта строка всегда с нулевым символом в конце даже если она была усечена.
Возвращаемое значение regerror - минимальный length, для сохранения всего сообщения об ошибках. Если он меньше чем length, то сообщение об ошибках не было усечено, и Вы можете использовать его. Иначе, Вы должны вызвать regerror снова с большим buffer.
Вот функция, которая использует regerror, но всегда динамически, резервируя буфер для сообщения об ошибках:
char *get_regerror (int errcode, regex_t *compiled)
{
size_t length = regerror(errcode,compiled,NULL,0);
char *buffer = xmalloc (length);
(void) regerror (errcode, compiled, buffer, length);
return buffer;
}
Разложение Слов означает процесс разбивания строки в слова и замену переменных, команд, и универсальных символов, точно так как делает оболочка.
Например, когда Вы пишите " ls -l foo.c ", эта строка разбивается в три отдельных слова " ls ", " -l " и " foo.c ". Это базисная функция разложения слов.
Когда Вы пишите " ls *.c ", это может стать многими словами, потому что слово " *.c " может быть заменено на любое число имен файлов. Это называется разложением универсального символа, и это также часть разложения слова.
Когда Вы используете " ECHO $PATH " чтобы печатать ваш путь, Вы пользуетесь преимуществом замены переменной, которая является также частью разложения слова.
Обычные программы могут выполнять разложение слова точно так же как оболочка, вызывая библиотечную функцию wordexp.
Когда разложение слова применяется к последовательности слов, выполняются следующие преобразования в порядке, показанном здесь:
Все функции, константы и типы данных для разложения слова объявлены в заглавном файле " wordexp.h ".
Разложение Слова производит вектор слов (строк). Чтобы возвращать этот вектор, wordexp использует специальный тип данных, wordexp_t, который является структурой. Вы передаете wordexp адрес структуры, и она вносит поля структуры, чтобы сообщить Вам результаты.
wordexp_t
Если Вы используете смещение отличное от нуля, то многие элементы в начале вектора будут оставлены пустыми. (Wordexp функция заполняет их пустыми указателями.) We_offs поле значимо только, если Вы используете WRDE_DOOFFS флаг. Иначе, смещение - всегда нуль независимо от того, что находится в этом поле, и первый реальный элемент находится в начале вектора.
int wordexp (const char *words, wordexp_t *word-vector-ptr, int flags)
Вы не должны использовать любой из символов " | & ; < > " в строке слов, если они не заключены в кавычки; аналогично для символа перевода строки. Если Вы используете эти символы без кавычек, Вы получите WRDE_BADCHAR код ошибки. Не используйте круглые скобки или фигурные скобки, если они заключены в кавычки или часть конструкции разложения слова. Если Вы используете кавычки " ' `, они должены войти попарно.
Результаты разложения слов - последовательность слов. Функция wordexp зарезервирует строку для каждого возникающего в результате слова, и вектор типа char **, чтобы сохранить адреса этих строк. Последний элемент вектора - пустой указатель. Этот вектор называется вектором слов.
Чтобы возвращать этот вектор, wordexp сохраняет, и адрес и длину (число элементов, не считая завершающий пустой символ) в *word vector-ptr.
Если wordexp завершает работу успешно, она возвращает 0. Иначе, она возвращает один из этих кодов ошибки:
Входные строковые слова содержат незащищенный кавычками недопустимый символ типа " | ".
Входная строка обращается к неопределенной переменной оболочки, и Вы использовали флаг WRDE_UNDEF, чтобы запретить такие ссылки.
Входная строка использует замену команды, и Вы использовала флаг WRDE_ NOCMD, чтобы запретить замену команд.
Было невозможно зарезервировать память для результат. В этом случае, wordexp может сохранять часть результатов, столько, сколько она смогла зарезервировать памяти.
Имелась синтаксическая ошибка во входной строке. Например, несогласованные кавычки - синтаксическая ошибка.
void wordfree (wordexp_t *word-vector-ptr) (функция)
Этот раздел описывает флаги, которые Вы можете определять в аргументе flags wordexp. Выберите флаги, которые Вы хотите, и объединяете их оператором |.
Добавляет слова этого разложения к вектору слов, произведенных предыдущими обращениями к wordexp.
Для этого Вы не должны изменять содержимое структуры вектора слов между обращениями к wordexp. И, если Вы устанавливаете WRDE_DOOFFS в первом обращении к wordexp, Вы должны также установить его, когда Вы добавляете.
Оставляет пустое место в начале вектора слов. We_offs поле говорит, сколько места оставить. Пустое место содержит пустые указатели.
Не делает замену команд; при попытке замены команды, сообщаает об ошибке.
Многократно использует вектор слов, сделанный предыдущим обращением к wordexp. Вместо того, чтобы зарезервировать новый вектор слов, это обращение к wordexp использует вектор, который уже существует (увеличивая его в случае необходимости).
Обратите внимание, что вектор может перемещаться в памяти, так что небезопасно хранить старый указатель и использовать его снова после вызова wordexp. Вы должны сохранять we_pathv после каждого обращения.
Покажет любые сообщения об ошибках.
Если ввод относится к переменной оболочки которая не определена, выдает ошибку.
Вот пример использования wordexp, чтобы рзложить отдельные строки и использования результатов чтобы выполнить команду оболочки. Он также показывает использование WRDE_APPEND, чтобы добавлять разложения и wordfree, чтобы освободить место, размещенное wordexp.
int
expand_and_execute(const char*program,const char*options)
{
wordexp_t result;
pid_t pid
int status, i;
switch (wordexp (program, &result, 0))
{
case 0:
break;
case WRDE_NOSPACE:
wordfree (&result);
default:
return -1;
}
for (i = 0; args[i]; i++)
{
if (wordexp (options, &result, WRDE_APPEND))
{
wordfree (&result);
return -1;
}
}
pid = fork ();
if (pid == 0)
{
execv (result.we_wordv[0],
result.we_wordv);
exit (EXIT_FAILURE);
}
else if (pid < 0)
status = -1;
else
if (waitpid (pid, &status, 0) != pid)
status = -1;
wordfree (&result);
return status;
Практически, т. к. wordexp работает, выполняя подоболочку, было бы быстрее сделать это, связывая строки с пробелами между ними и выполняя это как команду оболочки, используюя " sh -c ".
Эта глава описывает функции для управления датой и временем, включая функции для определения текущего времени и преобразование между различными представлениями времени.
Функции времени относятся к трем категориям:
Если вы пробуете оптимизировать вашу программу или измерять эффективность, очень полезно знать, сколько времени процессора или CPU времени она использовала в любой заданной точке. Процессорное время является отличным от фактических часов, потому что оно не включает все потраченное время на ожидание ввода-вывода или когда выполняется некоторый другой процесс. Процессорное время представляется типом данных clock_t, и дано как ряд импульсов времени относительно произвольного базового времени, отмечающего начало одиночного вызова программы.
Чтобы получить прошедшее CPU время, используемое процессом, Вы можете использовать функцию clock. Это средство объявлено в заглавном файле " time.h ".
Обычно, Вы вызываете функцию clock в начале и конца интервала, который Вы хотите измерить, вычитаете значения, и тогда делите на CLOCKS_PER_SEC (число импульсов времени clock в секунду), примерно так:
#include <time.h>
clock_t start, end;
double elapsed;
start = clock();
. . . /* Do the work. */
end = clock();
elapsed=((double)(end-start))/CLOCKS_PER_SEC;
В системе GNU, clock _t эквивалентен long int, а CLOCKS_PER_SEC - целочисленное значение. Но в других системах, и clock _t и тип макрокоманды CLOCKS_PER_SEC может быть или целое число, или с плавающей точкой. Приведением значения времени процессора к double, см. пример выше, удостоверяется, что нужные операции работают правильно и последовательно независимо от того, каково основное представление.
int CLOCKS_PER_SEC
int CLK_TCK
clock_t (тип данных)
clock_t clock (void) (функция)
Функция times возвращает более детализированную информацию относительно прошедшего процессорного времени в struct tmsobject. Вы должны включить заглавный файл " sys/times.h " чтобы использовать это средство.
struct tms (тип данных)
clock_t tms_utime
clock_t tms_stime
clock_t tms_cutime
clock_t tms_cstime
Все времена даны в импульсах сигналов времени. Они - абсолютные значения; в новом процессе, они - все нуль. См. Раздел 23.4 [Создание Процесса].
clock_t times (struct tms *buffer) (функция)
Возвращаемое значение - также как значение clock (): прошедшее реальное время относительно произвольной основы. Основа - константа внутри специфического процесса, и обычно представляет время начиная с запуска системы. Значение (clock_t) (-1) возвращается, чтобы указать отказ.
Примечание Переносимости: функция clock, описанная в Разделе 17.1.1 [Базисное процессорное Время], определена в соответствии c стандартом ANSI C. Функция times - возможность POSIX.1. В системе GNU, значение, возвращенное функцией clock эквивалентно сумме tms_utime и tms_stime полей, возвращенных times.
Этот раздел описывает средства для слежения за датами и временем согласно Грегорианскому календарю.
Имеются три представления информации даты и времени:
Этот раздел описывает time_t тип данных для представления календарного времени, и функции, которые используют объекты календарного времени. Эти средства объявлены в заглавном файле " time.h ".
time_t
В других системах, time_t может быть или целым числом или с плавающей запятой.
double difftime (time_t time1, time_t time0) (функция)
В системе GNU, Вы можете просто вычитать значения time_t. Но в других системах, time_t тип данных может использовать некоторое другое кодирование, где вычитание не работает непосредственно.
time_t time (time_t *result)
Тип данных time_t, используемый, чтобы представить календарное вермя имеет разрешающую способность только в одну секунду.
Некоторые приложения нуждаются в большей точности.
Так, библиотека GNU C также содержит функции, которые способны представить календарь с более высокой разрешающей способностью чем одна секунда. Функции и связанные типы данных, описанные в этом разделе объявлены в " sys/time.h ".
struct timeval (тип данных)
long int tv_sec
long int tv_usec
Некоторые значения struct timeval - используются для временных интервалов. Тогда tv_sec элемент - число секунд в интервале, а tv_usec - число микросекунд.
struct timezone (тип данных)
int tz_minuteswest
int tz_dsttime
Часто необходимо вычесть два значения типа struct timeval. Вот самый лучший способ делать это. Он работает даже на некоторых специфических операционных системах, где tv_sec элемент имеет тип unsigned.
int
timeval_subtract (result, x, y)
struct timeval *result, *x, *y;
{
if (x->tv_usec < y->tv_usec) {
int nsec = (y->tv_usec-x->tv_usec)/1000000+1;
y->tv_usec -= 1000000 * nsec;
y->tv_sec += nsec;
}
if (x->tv_usec - y->tv_usec > 1000000) {
int nsec = (y->tv_usec-x->tv_usec)/1000000;
y->tv_usec += 1000000 * nsec;
y->tv_sec -= nsec;
}
result->tv_sec = x->tv_sec - y->tv_sec;
result->tv_usec = x->tv_usec - y->tv_usec;
return x->tv_sec < y->tv_sec;
}
int gettimeofday (struct timeval *tp, struct timezone *tzp) (функция)
Возвращаемое значение - 0 при успехе и -1 при отказе. Следующее errno условие ошибки определено для этой функции:
операционная система не поддерживает получение информации часового пояса, и tzp - не пустой указатель. Операционная система GNU не поддерживает использование struct timezoneto для представления информации часового пояса; это - устаревшая возможность 4.3 BSD. Вместо этого, используйте средства, описанные в Разделе 17.2.6 [Функции Часового пояса].
int settimeofday (const struct timeval *tp, const struct timezone *tzp)
Вы должны быть привилегированным пользователем, чтобы использовать settimeofday.
Возвращаемое значение - 0 при успехе и -1 при отказе. Следующие errno условия ошибки определены для этой функции:
Этот процесс не может устанавливать время, потому что он не привилегированный.
операционная система не поддерживает установку информации часового пояса, и tzp - не пустой указатель.
int adjtime (const struct timeval *delta, struct timeval *olddelta)
Аргумент delta определяет относительную корректировку, которая будет сделана относительно текущего времени. Если он отрицателен, часы системы замедляются. Если положителен, часы системы ускоряются.
Если аргумент olddelta - не пустой указатель, функция adjtime, возвращает информацию относительно любой предыдущей корректировки, которая еще не завершилась.
Эта функция обычно используется, чтобы синхронизировать часы компьютеров в местной сети.
Вы должны быть привилегированным пользователем, чтобы использовать ее. Возвращаемое значение - 0 при успехе и -1 при отказе. Следующее errno условие ошибки определено для этой функции:
Вы не имеют привилегий, чтобы установить время.
Календарное время представляется как число секунд. Это удобно для вычисления, но не имеет никакого отношения к способу, которым люди обычно представляют даты и время. Нпротив, разделенное время двоичное представление, разделенное на год, месяц, день, и так далее.
Разделенное время всегда зависит от выбора зоны местного времени, и оно также указывает, какой часовой пояс использовался.
Символы в этом разделе объявлены в заглавном файле " time.h ".
struct tm
int tm_sec
int tm_min
int tm_hour
int tm_mday
int tm_mon
int tm_year
int tm_wday
int tm_yday
int tm_isdst
long int tm_gmtoff
Tm_gmtoff поле расширение библиотеки GNU.
const char *tm_zone
struct tm * localtime (const time_t *time) (функция)
Возвращаемое значение - указатель на статическую структуру разделенного времени, которая могла бы быть записана поверх последующими обращениями к любой из функций date и time. (Но никакая другая библиотечная функция не записывает поверх содержимого этого объекта.)
Вызов localtime имеет и другой эффект: она устанавливает переменную tzname с информацией относительно текущего часового пояса. См. Раздел 17.2.6 [Функции Часового пояса].
struct tm * gmtime (const time_t *time) (функция)
Вспомните, что календарное время всегда выражается в координированном универсальном времени.
time_t mktime (struct tm *brokentime) (функция)
Mktime функция игнорирует заданное содержимое tm_wday и tm_yday элементов структуры разделенного времени. Она использует значения других компонентов, чтобы вычислить календарное время; для этих компонентов допустимо иметь ненормализованные значения вне их нормальных диапазонов. Еще mktime корректирует компоненты структуры brokentime (включая tm_wday и tm_yday).
Если заданное разделенное время не может представляться как календарное время, mktime, возвращает значение (time_t) (-1) и не изменяет содержимое brokentime.
Вызов mktime также устанавливает переменную tzname с информацией относительно текущего часового пояса. См. Раздел 17.2.6 [Функции Часового пояса].
Функции, описанные в этом разделе форматирнуют значения времени как строки. Эти функции объявлены в заглавном файле " time.h ".
char * asctime (const struct tm *brokentime) (функция)
"Tue May 21 13:46:22 1991\n"
Сокращения для месяцев: `Jan', `Feb', `Mar', `Apr', `May', `Jun', `Jul', `Aug', `Sep', `Oct', `Nov', and `Dec'.
Возвращаемое значение указывает на статически размещенную строку, которая могла бы быть записана поверх последующими обращениями к любой из функций date и time. (Но никакая другая библиотечная функция не записывает поверх содержимого этой строки.)
char * ctime (const time_t *time)
size_t strftime (char *s, size_t size, const char *template, const struct tm *brokentime)
Обычные символы, появляющиеся в шаблоне копируются в строку вывода s; она может включать многобайтовые символы. Спецификаторы Преобразования представляются символом ` % ', и заменяются в строке вывода следующим образом:
Если s - пустой указатель, strftime не делает фактической записи чего-нибудь, но взамен возвращает число символов, которое она написала бы.
Для примера strftime, см. Раздел 17.2.7 [Пример Функции Времени].
В системе GNU, пользователь может определять часовой пояс посредством TZ переменной среды.
Для уточнения инфрмации относительно того, как устанавливать переменные среды, см. Раздел 22.2 [Переменные среды]. Функции для доступа к часовому поясу объявлены в " time.h ".
Значение TZ переменной может иметь один из трех форматов. Первый формат используется, когда не имеется никакого Смещения светового дня (или в летнее время) в зоне местного времени:
std offset
Смещение определяет значение которое нужно добавить к местному времени, чтобы получить значение Координированного Универсального времени. Она имеет синтаксис подобно [+ | -] hh [: mm [: ss]]. Она положительно, если зона местного времени - к западу от Главного меридиана и отрицательно, если она восточнее. Час должен быть от 0 до 24, а минуты и секунды от 0 до 59.
Например, вот, как мы определили бы Восточное Стандартное Время, но без любых Смещений Светового дня:
EST+5
std offset dst [offset],start[/time],end[/time]
Остаточный член от спецификации описывает, когда смещение светового дня действует. Поле start - то, когда смещение светового дня входит в силу, а поле end - то, когда изменение будет сделано обратно к стандартному времени. Следующие форматы распознаваемы для этих полей: Jn определяет Юлианский день, с n между 1 и 365. 29 февраля никогда не рассчитывается, даже в високосные годы. N определяет Юлианский день, с n между 0 и 365. 29 февраля рассчитан в високосные годы. Mm.w.d определяет день d недели w месяца m. день d должен быть между 0 (воскресеньем) и 6. Неделя w должна быть между 1 и 5; неделя 1 - первая неделя, в которой есть день d , а неделя 5 определяет последний d день в месяце. Месяц m должен быть между 1 и 12.
Поля time определяют, когда, по местному времени происходит изменение к другому времени. Значение по умолчанию - 02:00:00.
Например, вот, как можно определить Восточный часовой пояс в Соединенных Штатах, включая соответствующее смещение светового дня и даты применимости. Нормальное смещение ПО ГРИНВИЧУ - 5 часов; так как это - к западу от главного меридиана, знак положителен. Летний период начинается в первое воскресенье апреля в 2:00am, и кончается в последнее воскресенье октября в 2:00am.
EST+5EDT,M4.1.0/M10.5.0
Чтобы быть строго правильным, преобразование дат и времени должно быть основано на действующем плане. Однако, система не имеет никаких средств, чтобы допустить Вам определять, как план изменился. Наибольшее что Вы может сделать - определить один специфический план обычно план текущего дня.
Третий формат походит на:
:characters
Если переменная среды TZ не имеет значения, операция выбирает часовой пояс по умолчанию. Каждая операционная система имеет собственные правила для выбора заданного по умолчанию часового пояса, так что относительно этого мы можем сказать совсем немного.
char * tzname [2] (переменная)
void tzset (void)
Следующие переменные определены для совместимости с System V Unix. Эти переменные устанавливаются вызоввом localtime.
long int timezone
int daylight
Вот пример программы, показывающий использование некоторых функций местного и календарного времени.
#include <time.h>
#include <stdio.h>
#define SIZE 256
int
main (void)
{
char buffer[SIZE];
time_t curtime;
struct tm *loctime;
curtime = time (NULL);
loctime = localtime (&curtime);
fputs (asctime (loctime), stdout);
strftime (buffer, SIZE,
"Today is %A, %B %d.\n", loctime);
fputs (buffer, stdout);
strftime (buffer, SIZE,
"The time is %I:%M %p.\n", loctime);
fputs (buffer, stdout);
return 0;
}
Wed Jul 31 13:02:36 1991
Today is Wednesday, July 31.
The time is 01:02 PM.
Функции alarm и setitimer обеспечивают механизм прерывания процесса, в некоторое время. Они делают это, устанавливая таймер; когда время таймер истекает, процесс получает сигнал.
Каждый процесс имеет три доступных независимых таймера интервала:
Вы должны установить обработчик для соответствующего сигнала alarm, используюя signal или sigaction перед обращением к setitimer или alarm. Иначе, необычная цепочка событий может заставлить таймер исчерпать время прежде, чем ваша программа установит обработчик, и в этом случае она будет завершена, так как это - заданное по умолчанию действие для сигналов alarm. См. Главу 21 [Обработка Сигнала].
Функция setitimer - первичный способ для установки будильника. Это средство объявлено в заглавном файле " sys/time.h ". Функция alarm, объявленная в " unistd.h ", обеспечивает несколько более простой интерфейс для установки таймера в реальном времени.
struct itimerval (тип данных)
struct timeval it_interval
struct timeval it_value
Тип данных Struct timeval описан в Разделе 17.2.2 [Календарь с высоким разрешением].
int setitimer (int which, struct itimerval *old, struct itimerval *new)
Если old - не пустой указатель, setitimer возвращает информацию относительно любого предыдущего неистекшего таймера того же самого вида в структуре, на которую он указывает.
Возвращаемое значение - 0 при успехе и -1 при отказе. Следующие errno условия ошибки определены для этой функции:
интервал таймера был слишком большой.
int getitimer (int which, struct itimerval *old)
Возвращаемое значение и условия ошибки - такие же как для setitimer.
ITIMER_REAL
ITIMER_VIRTUAL
ITIMER_PROF
unsigned int alarm (unsigned int seconds)
Возвращаемое значение указывает, сколько секунд оставалось прежде, чем предыдущий сигнал был бы послан. Если не было никакого предыдущего сигнала, alarm возвращает нуль.
Функция alarm могла бы быть определена в терминах setitimer примерно так:
unsigned int
alarm (unsigned int seconds)
{
struct itimerval old, new;
new.it_interval.tv_usec = 0;
new.it_interval.tv_sec = 0;
new.it_value.tv_usec = 0;
new.it_value.tv_sec = (long int) seconds;
if (setitimer (ITIMER_REAL, &new, &old) < 0)
return 0;
else
return old.it_value.tv_sec;
}
Если Вы просто хотите, чтобы ваш процесс ждал данное число секунд, Вы должен использовать функцию sleep. См. Раздел 17.4 [Sleep].
Вы не должны рассчитать на сигнал, прибывающий точно, когда таймер истекает. В многопроцессорной среде имеется обычно некоторая задержка.
Примечание Переносимости: setitimer и getitimer - функции UNIX BSD, в то время как функция alarm определена POSIX.1 стандартом. Setitimer более мощная чем alarm, но alarm более широко используется.
Sleep дает простой способ заставить программу ждать некоторый период времени. Если ваша программа не использует сигналы (за исключением завершения), то Вы можете расчитывать, что sleep будет ждать заданное количество времени. Иначе, sleep может возвращаться, если прибывает сигнал; если Вы хотите ждать данный период независимо от сигналов, используйте select (см. Раздел 8.6 [Ждущий ввод - вывод] ) и не определяйте ни каких описателей ожидания.
unsigned int sleep (unsigned int seconds)
Если функция sleep возвращает значение по истечении времени, то это значение нуль. Если она возвращается после сигнала, возвращаемое значение - остающееся время ожидания sleep.
Функция sleep объявлена в " unistd.h ".
Вы можете использовать select и делать период ожидания, совершенно точным. (Конечно, загрузка системы может вызывать неизбежные дополнительные задержки, если машина не специализирована одному приложению, не имеется никакого способа, которым Вы можете избежать этого.)
Функция getrusage и тип данных struct rusage используется для исследования типа использования процесса. Они объявлены в " sys/resource.h ".
int getrusage (int processes, struct rusage *rusage)
В большинстве систем, processes имеет только два допустимых значения:
RUSAGE_SELF
RUSAGE_CHILDREN
В системе GNU, Вы можете также запрашивать относительно специфического дочернего процесса, определяя ID процесса.
Возвращаемое значение getrusage - нуль при успехе, и -1 при отказе.
Аргумент EINVAL processes не допустим.
Еще один способ получения типа использования для специфического дочернего процесса - функцией wait4, которая возвращает общие количества для дочернего процесса при его завершении. См. Раздел 23.8 [BSD Функции Ожидания].
struct rusage
struct timeval ru_utime
struct timeval ru_stime
long ru_majflt
long ru_inblock
long ru_oublock
long ru_msgsnd
long ru_msgrcv
long ru_nsignals
Дополнительная историческая функция для исследования типов использования, vtimes, обеспечивается но здесь не описана. Она объявлена в " sys/vtimes.h ".
Вы можете определять ограничения использования ресурса для процесса. Когда процесс пробует превышать ограничение, он может терпеть неудачу, в зависимости от ограничения. Каждый процесс первоначально наследует значения ограничений от родителя, но он может впоследствии изменять их.
Символы в этом разделе определены в " sys/resource.h ".
int getrlimit (int resource, struct rlimit *rlp) (функция)
Возвращаемое значение - 0 при успехе и -1 при отказе. Единственое возможное errno условие ошибки - EFAULT.
int setrlimit (int resource, struct rlimit *rlp) (функция)
Возвращаемое значение - 0 при успехе и -1 при отказе. Следующее errno условие ошибки возможно:
Вы пробовали изменять максимально допустимое значение ограничения, но Вы не имеете привилегий, чтобы сделать это.
struct rlimit (тип данных)
Rlim_cur Текущее значение рассматриваемого ограничения.
Rlim_max Максимально допустимое значение рассматриваемого ограничения. Вы не можете устанавливать текущее значение ограничения больше чем этот максимум. Только root может изменять максимально допустимое значение.
В getrlimit, эта структура - вывод; она получает текущие значения. В setrlimit она определяет новые значения.
Вот список ресурсов, для которых Вы можете определять ограничения.
RLIMIT_CPU
RLIMIT_FSIZE
RLIMIT_DATA
RLIMIT_STACK
RLIMIT_CORE
RLIMIT_RSS
RLIMIT_OPEN_FILES
RLIM_NLIMITS
int RLIM_INFINITY
Две исторических функции для установки ограничений ресурса, ulimit и vlimit, не зарегистрированы здесь. Они объявлены в " sys/vlimit.h " и исходят ИЗ BSD.
Когда отдельные процессы выполняются, их приоритеты определяют то, какую часть ресурсов CPU каждый процесс получает. Этот раздел описывает, как Вы можете читать и устанавливать приоритет процесса. Все эти функции и макрокоманды объявлены в " sys/resource.h ".
Промежуток допустимых значений зависит от операционной системы, но обычно он выполняется от -20 до 20. Меньшее значение приоритета означает что процесс выполняет чаще. Эти константы описывают некоторые значения: PRIO_MIN самое маленькое допустимое значение приоритета. PRIO_MAX самое большое допустимое значение приоритета.
int getpriority (int class, int id) (функция)
Возвращаемое значение - значение приоритета при успехе, и -1 при отказе. Следующее errno условие ошибки возможно для этой функции:
комбинация class и id не соответствует никакому существующему процессу.
значение class не допустимо.
Единственый способ различить состоит в том, чтобы установить errno = 0 перед вызовом getpriority, и тогда использовать errno!= 0 позже как критерий для отказа.
int setpriority (int class, int id, int priority) (функция)
Возвращаемое значение - 0 при успехе и -1 при отказе. Следующее errno условие ошибки определено для этой функции:
комбинация class и id не соответствует никакому существующему процессу.
значение класса не допустимо.
Вы пробовали устанавливать приоритет процесса некоторого другого пользователя, и Вы не имеете привилегий для этого.
Вы пробовали понизить приоритет процесса, и Вы не имеете привилегий для этого.
PRIO_PROCESS
PRIO_PGRP
PRIO_USER
Если id аргумент - 0, то обрабатывается текущий процесс, текущая группа процесса, или текущий пользователь, согласно классу.
int nice (int increment) (функция)
Вот эквивалентное определение для nice:
int
nice (int increment)
{
int old = getpriority (PRIO_PROCESS, 0);
setpriority (PRIO_PROCESS,0,old+increment);
}
Ряд языков использует наборы символов, которые больше чем набор значений типа char.
Японский и Китайский - возможно наиболее близкие примеры.
Библиотека GNU C включает поддержку двух механизмов для работы с расширенными наборами символов: многобайтовые символы и широкие символы. Эта глава описывает, как использовать эти механизмы, и функции для преобразования между ними.
На поведение функций в этой главе воздействует текущий стандарт для символьной классификации LC_CTYPE класса; см. Раздел 19.3 [Категории Стандарта]. Этот стандарт указывает, который многобайтовый код используется, и также управляет значениями и характеристиками расширенных символьных кодов.
Вы можете представлять расширенные символы одним из двух способов:
Если ваша система поддерживает расширение символов, то она поддерживает их, и как многобайтовые символы и как расширенные символы. Библиотека включает функции, которые Вы можете использовать, чтобы преобразовать между двумя представлениями. Эти функции описаны в этой главе.
Компьютерная система может поддерживать больше чем один многобайтовый символьный код, и больше чем один расширенный символьный код. Пользователь управляет выбором кодов через текущий стандарт для символьной классификации (см. Главу 19 [Стандарты] ). Каждый стандарт определяет специфический многобайтовый символьный код и специфический расширенный символьный код. Выбор стандарта влияет на поведение функций преобразования в библиотеке.
Некоторые стандарты не поддерживают ни расширенные символы, ни нетривиальные многобайтовые символы. В этих стандартах, библиотечные функции преобразования все еще работают, даже если, что они в основном тривиальны.
Если Вы выбираете нновый стандарт для символьной классификации, внутренний параметр сдвига, поддерживаемый этими функциями может стать спутанным, так что - не стоит изменять стандарт в то время как, Вы находитесь в середине обработки строки.
В обычном коде ASCII, последовательность символов последовательность байтов, и каждый символ - один байт. Это очень просто, но учитывает только 256 различных символов.
В многобайтовом символьном коде, последовательность символов последовательность байтов, но каждый символ может занимать одни или более последовательных байт последовательности.
Имеются много различных способов проектирования многобайтового символьного кода; различные системы используют различные коды. Специфический способ кодирования определяется обозначением базисных последовательностей байтов, которые представляют одиночный символ и какие символы они замещают. Код, который компьютер может фактически использовать, должен иметь конечное число этих базисных последовательностей, и обычно ни одна из них не длиннее чем несколько символов.
Эти последовательности не имеют одинаковую длину. Фактически, многие из их - только один байт. Потому что базисные символы ASCII в промежутке от 0 до 0177 настолько важны, что они замещают себя во всех многобайтовых символьных кодах. То есть байт, чье значение от 0 до 0177 - всегда символ сам по себе. Символы, которые больше чем один байт, должны всегда начинаться с байта в промежутке от 0200 до 0377.
Значение 0 байта может использоваться, чтобы завершить строку, точно как это часто используется в строке символов ASCII.
Определение базисных последовательностей байтов, которые представляют одиночные символы автоматически дают значения более длинным последовательностям байтов, больше чем один символ. Например, если последовательность два байта 0205 049 замещает символ греческой альфы, то 0205 049 065 должна заместить альфу, сопровождаемую " " (код ASCII 065), а 0205 049 0205 049 должна заместить две альфы в строке.
Если любая последовательность байтов может иметь больше чем одно значение как последовательность символов, то многобайтовый код неоднозначен и опасен. Коды, которые системы фактически используют все однозначны.
В большинстве кодов, имеются некоторые последовательности байтов, которые не имеют никакого значения как символ или символы. Они называются недопустимыми.
Самый простой возможный многобайтовый код - тривиальный:
Базисные последовательности состоят из одиночных байтов.
Данный специфический код не использует многобайтовые символы вообще. Он не имеет никаких недопустимых последовательностей. Но он может обрабатывать только 256 различных символов.
Вот другой возможный код, который может обрабатывать 9376 различных символов:
Базисные последовательности состоят из
Этот код или подобный используется на некоторых системах, чтобы представить Японские символы. Недопустимые последовательности - те, которые состоят из нечетного числа последовательных байтов в промежутке от 0240 до 0377.
Вот другой многобайтовый код, который может обрабатывать больше различных расширенных символов, фактически, почти тридцать миллионов:
Базисные последовательности состоят из
Вот другой вариант, который имеет преимущество: при удалении последнего байта или байтов допустимого символа, никогда не может появиться другой допустимый символ.
Базисные последовательности состоят из
Список недопустимых последовательностей для этого кода довольно длинный и не стоит полного просмотра; примеры недопустимых последовательностей включают 0240 и 0220 0300 065.
Число возможных многобайтовых кодов очень велико. Но данная компьютерная система будет поддерживать не больше нескольких различных кодов. (Один из этих кодов может учитывать тысячи различных символов.) Другая компьютерная система может поддерживать полностью отличный код. Библиотечные средства, описанные в этой главе полезны, потому что они описывают подробности многобайтового кода специфической компьютерной системы, хотя ваши программы не должны знать.
Вы можете использовать специальные стандартные макрокоманды, чтобы выяснить максимальное возможное число байтов символа в текущем многобайтовом коде ипользуйте MB_CUR_MAX, а максимум для любого многобайтового кода, обеспечиваемого на вашем компьютере содержится в MB_LEN_MAX.
int MB_LEN_MAX (макрос)
int MB_CUR_MAX (макрос)
MB_CUR_MAX определен в " stdlib.h ".
Что случается, если Вы пробуете передавать строку, содержащую многобайтовые символы функции, которая не знает о них? Обычно, такая функция обрабатывает строку как последовательность байтов, и интерпретирует некоторые значения особенно; все другие значения байтов "обычны". Если многобайтовый символ не содержит специальное значение байта, функция должна обработать его, как будто это были отдельные обычные символы.
Расширенные символы намного проще чем многобайтовые символы. Они - просто символы с больше, чем восемью битами, так, чтобы они имели место для больше, чем 256 различных кодов. Расширенный символьный тип данных wchar_t, имеет достаточно большой диапазон, чтобы содержать расширенные символьные коды также как традиционные коды ASCII.
Преимущество расширенных символов - в том, что каждый символ является одиночным объектом данных, точно так же как обычные символы ASCII. Эти символы также имеют некоторые недостатки:
wchar_t (тип данных)
Если ваша система поддерживает расширенные символы, то каждый расширенный символ имеет и расширенный символьный код и соответствующую многобайтовую базисную последовательность.
В этой главе, термин код используется, чтобы обратиться к одиночному расширенному символьному объекту, чтобы подчеркнуть различие от типа данных char.
Функция mbstowcs преобразовывает строку многобайтовых символов в массив расширенных символов. Функция wcstombs делает обратный процесс. Эти функции объявлены в заглавном файле " stdlib.h ".
В большинстве программ, эти функции - единственная Ваша потребность в преобразовании между расширенными строками и многобайтовыми символьными строками. Но они имеют ограничения. Если ваши данные не с нулевым символом в конце или - не все в ядре сразу, Вы возможно должны использовать функции преобразования низкого уровня, чтобы преобразовать один символ за раз. См. Раздел 18.7 [Преобразование Одного Символа].
size_t mbstowcs (wchar_t *wstring, const char *string, size_t size)
Преобразование символов из строки начинается с начальным параметром регистра.
Если недопустимая многобайтовая символьная последовательность найдена, функция возвращает значение -1. Иначе, она возвращает число расширенных символов, сохраненных в массиве wstring. Это число не включает пустой символ завершения, который присутствует, если число меньше, чем size.
Вот пример, показывающий, как преобразовывать строку многобайтовых символов, резервируя достаточное пространство для результата.
wchar_t *
mbstowcs_alloc (const char *string)
{
size_t size = strlen (string) + 1;
wchar_t *buf = xmalloc (size * sizeof (wchar_t));
size = mbstowcs (buf, string, size);
if (size == (size_t) -1)
return NULL;
buf = xrealloc (buf, (size + 1) * sizeof (wchar_t));
return buf;
}
size_t wcstombs (char *string,const wchar_t wstring,size_t size)
Если найден код, который не соответствует допустимому многобайтовому символу, то эта функция возвращает значение -1. Иначе, возвращаемое значение - число байтов, сохраненных в массиве. Это число не включает пустой символ завершения, который присутствует, если число - меньше чем size.
Этот раздел описывает, как просмотреть строку, содержащую многобайтовые символы, по одному символу. Трудность в том, что нужно знать, сколько байтов каждый символ содержат. Ваша программа может использовать mblen, чтобы узнать это.
int mblen (const char *string, size_t size)
Возвращаемое значение mblen отличает три возможности: первые size байт строки начинаются с допустимого многобайтового символа, они начинаются с недопустимой последовательности байтов или включают только часть символа, или string указывает на пустую строку (пустой символ).
Для допустимого многобайтового символа, mblen возвращает число байтов в этом символе (всегда по крайней мере 1, и никогда не больше чем size). Для недопустимой последовательности байтов, mblen возвращает -1. Для пустой строки, она возвращает 0.
Если многобайтовый символьный код использует символы смены регистра, то mblen, поддерживает и модифицирует параметр регистра. Если Вы вызываете mblen с пустым указателем для строки, она инициализирует параметр регистра к стандартному начальному значению. См. Раздел 18.9 [Параметра Регистра] .
Функция mblen объявлена в " stdlib.h ".
Вы можете преобразовывать многобайтовые символы в расширенные символы по одному mbtowc функцией. Wctomb функция делает обратное. Эти функции объявлены в " stdlib.h ".
int mbtowc (wchar_t *result, const char *string, size_t size)
Для допустимого многобайтового символа, mbtowc преобразовывает его в расширенный символ, сохраняет его в *result, и возвращает число байтов в том символе (всегда по крайней мере 1, и никогда не болольше чем size).
Для недопустимой последовательности байтов, mbtowc возвращает 1. Для пустой строки, она возвращает 0, также сохраняя 0 в *result.
int wctomb (char *string, wchar_t wchar)
Если wchar - недопустимый расширенный символьный код, wctomb возвращает -1. Если wchar - 0, она возвращает 0, также сохраняя 0 в *string.
Вызов этой функции с нулевым wchar аргументом, когда строка - не пустой символ, имеет побочный эффект переинициализации сохраненного параметра регистра также как сохранения многобайтового символа 0 и возвращения 0.
Вот пример, который читает многобайтовоый-символьный текст из дескриптора input и записывает соответствующие расширенные символы в описатель output. Мы должны преобразовать символы один за другим в этом примере, потому что mbstowcs неспособна продолжиться после пустого символа, и не может справляться с очевидно недопустимым частичным символом, читая большое количество ввода.
int
file_mbstowcs (int input, int output)
{
char buffer[BUFSIZ + MB_LEN_MAX];
int filled = 0;
int eof = 0;
while (!eof)
{
int nread;
int nwrite;
char *inp = buffer;
wchar_t outbuf[BUFSIZ];
wchar_t *outp = outbuf;
nread = read (input, buffer +
filled, BUFSIZ);
if (nread < 0)
{
perror ("read");
return 0;
}
if (nread == 0)
eof = 1;
filled += nread;
while (1)
{
int thislen = mbtowc (outp,
inp, filled);
if (thislen == -1)
break;
if (thislen == 0) {
thislen = 1;
mbtowc (NULL, NULL, 0);
}
inp += thislen;
filled -= thislen;
outp++;
}
nwrite = write (output, outbuf,
(outp-outbuf)*sizeof(wchar_t));
if (nwrite < 0)
{
perror ("write");
return 0;
}
if ((eof && filled > 0) ||
filled >= MB_CUR_MAX)
{
error ("invalid
multibyte character");
return 0;
}
if (filled > 0)
memcpy (inp, buffer, filled);
}
return 1;
}
В некоторых многобайтовых символьных кодах, значение любой специфической последовательности байтов не фиксировано; оно зависит от других последовательностей рассмотренных ранее в той же самой строке. Обычно имеются только несколько последовательностей, которые могут изменять значение других последовательностей; эти немногие называются последовательностями регистров, и мы говорим, что они устанавливают параметр регистра для других последовательностей, которые последуют.
Чтобы проиллюстрировать состояние регистра и последовательности регистров, предположите, что мы устанавливаем, что последовательность 0200 (только один байт) вводит Японский режим, в котором пары байтов в промежутке от 0240 до 0377 являются одиночными символами, в то время как 0201 вводит Латинский-1 режим, в котором одиночные байты в промежутке от 0240 до 0377 являются символами, и интерпретируются согласно набору символов Latin-1 Международной организации по стандартизации. Это - многобайтовый код, который имеет два альтернативных состояния регистра ("Японский режим " и " Латинский-1 режим "), и две последовательности регистров, которые определяют специфические состояния регистра.
Когда используемый многобайтовый символьный код имеет состояния регистра, то mblen, mbtowc и wctomb должны поддерживать и модифицировать текущее состояние регистра, поскольку они просматривают строку. Чтобы делать эту работу правильно, Вы должны следовать этим правилам: * Перед стартом просмотра строки, вызовите функцию с пустым указателем для многобайтового символьного адреса например, mblen (NULL, 0). Это инициализирует состояние регистра к стандартному начальному значению. * Просматривайте строку по одному символу. Не "возвращайтесь" и не перепросмотривайте уже просмотренные символы, и не смешивайте обработку различных строк.
Вот пример использования mblen с соблюдением этих правил:
void
scan_string (char *s)
{
int length = strlen (s);
mblen (NULL, 0);
while (1)
{
int thischar = mblen (s, length);
if (thischar == 0)
break;
if (thischar == -1)
{
error ("invalid multibyte
character");
break;
}
s += thischar;
length -= thischar;
}
}
Различные страны имеют изменяющиеся стандарты. Эти стандарты содержит преобразования от очень простых, типа формата для представления дат и времени, до очень сложных, типа разговорного языка.
Межнационализация программного обеспечения означает способность к адаптированию программирования для соглашений предпочитаемых пользователем. В ANSI C, межнационализация работает посредством стандартов. Каждый стандарт определяет набор соглашений, одно соглашение для каждой цели. Пользователь выбирает набор соглашений, определяя стандарт (через переменные среды).
Все программы наследуют выбранный стандарт как часть их среды.
Это определяет соглашения для отдельных целей, включая следующие:
Эта глава обсуждает механизм, которым Вы можете изменять текущий стандарт. Эффекты текущего стандарта на специфических библиотечных функциях обсуждены более подробно в описаниях самих функций.
Самый простой способ для пользователя, чтобы выбрать стандарт состоит в том, чтобы установить переменную среды LANG. Она определяет один стандарт для всех целей. Например, пользователь мог бы определить гипотетический стандарт, именованный " espana castellano " чтобы использовать стандартные соглашения Испании.
Набор обеспечиваемых стандартов зависит от операционной системы, которую Вы используете. Мы не можем делать ни каких обещаний относительно того, что стандарты будут существовать, кроме одного стандартного стандарта, называемого " C " или " POSIX ".
Пользователь также имеет опцию определения различных стандартов для различных целей, выбирая смесь многих стандартов.
Цели, которые стандарты обслуживают, сгруппированы в категории так, чтобы пользователь или программа мог выбирать стандарт для каждого класса независимо. Вот таблица категорий: каждое имя является и переменной среды, которую пользователь может устанавливать, и именем макрокоманды, которую Вы можете использовать как аргумент setlocale.
LC_COLLATE
LC_CTYPE
LC_MONETARY
LC_NUMERIC
LC_TIME
LC_ALL
LANG
Программа на Си наследует переменные среды стандарта, когда она начинается. Это случается автоматически. Однако, эти переменные автоматически не управляют стандартом, используемым в соответствии c библиотечными функциями, потому что ANSI C говорит, что все программы начинаются по умолчанию в стандарте " C ". Чтобы использовать стандарты, заданные средой, Вы должны вызвать setlocale. Вызовите ее следующим образом:
setlocale (LC_ALL, "");
Вы можете также использовать setlocale, чтобы определить специфический стандарт, для общего использования или для специфического класса.
Символы в этом разделе определены в заглавном файле " locale.h".
char * setlocale (int category, const char *locale)
Если класс - LC_ALL, то она определяет стандарт для всех целей. Другие возможные значения класса определяют индивидуальную цель (см. Раздел 19.3 [Категории Стандарта] ).
Вы можете также использовать эту функцию, чтобы выяснить текущий стандарт, передавая пустой указатель как аргумент стандарта. В этом случае, setlocale возвращает строку, которая является именем стандарта, в настоящее время выбранного для класса class.
Строка, возвращенная setlocale может быть записана поверх последующими обращениями, так что Вы должны делать копию строки (см. Раздел 5.4 [Копирование и Конкатенация]) если Вы хотите сохранять ее после любых дальнейших обращений к setlocale. (Стандартная библиотека, как гарантируют, никогда не вызовет setlocale непосредственно.)
Вы не должны изменять строку, возвращенную setlocale. Это может быть та же самая строка, которая была передана как аргумент в предыдущем обращении к setlocale.
Когда Вы читаете текущий стандарт для класса LC_ALL, значение кодирует всю комбинацию выбранных стандартов для всех категорий. В этом случае, значение не только одиночное имя стандарта. Фактически, мы не делаем ни каких обещаний относительно того, на что это походит. Но если Вы определяете то же самое " имя стандарта" LC_ALL в последующем обращении к setlocale, она восстанавливает ту же самую комбинацию выборов стандарта.
Когда аргумент locale - не пустой указатель, строка, возвращенная setlocale отражает изменяемый стандарт.
Если Вы определяете пустую строку для стандарта, это означает, что нужно читать соответствующую переменную среды и использовать ее значение для установки стандарта указанного класса.
Если Вы определяете недопустимое имя стандарта, setlocale, возвращает пустой указатель и оставляет текущий стандарт неизмененным.
Вот пример, показывающий, как Вы могли бы использовать setlocale, чтобы временно включить к новый стандарт.
#include <stddef.h>
#include <locale.h>
#include <stdlib.h>
#include <string.h>
void
with_other_locale (char *new_locale,
void (*subroutine) (int),
int argument)
{
char *old_locale, *saved_locale;
old_locale = setlocale (LC_ALL, NULL);
saved_locale = strdup (old_locale);
if (old_locale == NULL)
fatal ("Out of memory");
setlocale (LC_ALL, new_locale);
(*subroutine) (argument);
setlocale (LC_ALL, saved_locale);
free (saved_locale);
}
Единственые имена стандартов, которые Вы можете находить во всех операционных системах - это три стандартных: "C" Это - стандартный стандарт Cи. Атрибуты и поведение, которое он обеспечивает определены в стандарте ANSI C. Когда ваша программа начинается, она первоначально использует этот стандарт по умолчанию. " POSIX " Это - стандартный стандарт POSIX. В настоящее время, это - побочный результат исследования для стандартного стандарта Cи. "" Пустое имя говорит о том, что нужно выбрать стандарт, основанный на переменных среды. См. Раздел 19.3 [Категории Стандарта].
Определение и установка стандартов - обязаность вашего администратора системы (или человека, который установил библиотеку GNU C). Некоторые системы могут позволять пользователям создавать стандарты, но мы не обсуждаем это здесь.
Если ваша программа должна использовать кое-что отличное от "C" стандарт, она будет более переносимой, если Вы используете стандарт, который пользователь определяет со средой, а не пробуя определить некоторый ненормативный стандарт явно именем. Помните, что различные машины могут иметь различные наборы устанавливаемых стандартов.
Когда Вы хотите форматировать число или количество валюты, используя соглашения текущего стандарта, Вы можете использовать функцию localeconv, чтобы получить данные относительно того, как делать это. Функция localeconv объявлена в заглавном файле "locale.h ".
struct lconv * localeconv
Вы не должны измениять структуру или ее содержимое. Структура может быть записана поверх последующими обращениями к localeconv, или обращениями к setlocale, но никакая другая функция в библиотеке не записывает поверх этого значения.
struct lconv
Если элемент структуры struct lconv имеет тип char, и значение CHAR_MAX, это означает что текущий стандарт не имеет никакого значения для этого параметра.
Это - стандартные элементы struct lconv; хотя могут иметься и другие.
char *decimal_point
char *mon_decimal_point
char *thousands_sep
char *mon_thousands_sep
char *grouping
char *mon_grouping
Каждая строка состоит из десятичных чисел, отделяемых точками с запятой. Последовательные числа (слева направо) дают размеры последовательных групп (справа налево, начиная с десятичной точки). Последнее число в строке используется много раз для всех оставшихся групп.
Если последним целым числом является -1, это означает, что любые остающиеся цифры формируются в одну большую группу без разделителей.
Например, при - "4;3;2", правильная группировка для числа 123456787654321 будет " 12 ", " 34 ", " 56 ", " 78 ", " 765 ", " 4321 ". С разделителем ",", число было бы напечатано как " 12,34,56,78,765,4321 ".
Значение "3" указывает повторение группы из трех цифр, как обычно используется в США.
В стандарте " C ", и grouping и mon_grouping имеют значения "". Это значение не определяет никакой группировки вообще.
char int_frac_digits
char frac_digits
В стандарте " C ", оба этих элемента имеют значение CHAR_MAX, означая "неопределенный".
Мы рекомендуем не печатать никаких дробных цифр. (Этот стандарт также определяет пустую строку для mon_decimal_point, так печать любых дробных цифр только путала бы!)
Эти элементы структуры struct lconv определяют, как печатать символ, чтобы идентифицировать валютное значение международный аналог " $ ".
Каждая страна имеет два стандартных символа валюты. Местный символ валюты используется обычно внутри страны, в то время как международный символ валюты используется всемирно, чтобы обратиться к валюте этой страны, когда необходимо указать страну недвусмысленно.
Например, многие страны используют доллар в качестве денежной единицы, но для международных валют важно определить, что мы имеем дело с Канадскими долларами, вместо Американских долларов или Австралийских долларов. Но когда контекст известен, не имеется никакой потребности объявлять эти явные долларовые количества в Канадских долларах.
char *currency_symbol
В стандарте " C ", этот элемент имеет значение "" (пустая строка), означая "неопределенный". Стандарт ANSI не говорит, что делать, когда Вы находите это значение; мы рекомендуем, чтобы Вы просто печатали пустую строку, как Вы печатали бы любую другую строку, найденную в соответствующем элементе.
char *int_curr_symbol
Значение int_curr_symbol должно обычно состоять из трех символьного сокращения, определенного Международной организацией по стандартизации международного эталона как один из 4217 Кодов для Представления Валюты и Фондов, сопровождаемых разделителем (часто пробел).
В стандарте " C ", этот элемент имеет значение "" (пустая строка), означая "неопределенный". Мы рекомендуем, чтобы Вы просто печатали пустую строку, как Вы печатали бы любую другую строку, найденную в соответствующем элементе.
char p_cs_precedes
char n_cs_precedes
В стандарте " C ", оба этих элемента имеют значение CHAR_MAX, означая "неопределенный". Стандарт ANSI не говорит, что делать, когда Вы находите это значение, но мы рекомендуем печатать символ валюты перед числом. Это - правильно для большинства стран. Другими словами, обработайте все значения отличные от нуля подобно этим элементам.
Стандарт POSIX говорит, что эти два элемента обращаются к int_curr_symbol также как currency_symbol. Стандарт ANSI C, кажется, подразумевает, что они должны применяться только к currency_symbol_so, int_curr_symbol должен всегда предшествовать количеству.
Мы можем только предполагать, которое из этих соответствует обычному соглашению для печати международных символов валюты. Наше предположение - то, что они должны всегда предшествовать количеству. Если мы выясим точный ответ, мы поместим его здесь.
char p_sep_by_space
char n_sep_by_space
В стандарте "C", оба этих элемента имеют значение CHAR_MAX, означая "неопределенный". Стандарт ANSI не говорит, что Вы должны делать, когда Вы находите это значение; мы предлагаем, чтобы Вы обрабатывали это как 1 (печатайте пробел). Другими словами, обрабатывайте все значения отличные от нуля подобно этому элементу.
Эти элементы применяются только к currency_symbol. Когда Вы используете int_curr_symbol, Вы никогда не печатаете дополнительный пробел, потому что int_curr_symbol непосредственно содержит соответствующий разделитель.
Стандарт POSIX говорит, что эти два элемента обращаются к int_curr_symbol также как currency_symbol. Но пример в стандарте ANSI C ясно подразумевает, что они должны применяться только к currency_symbol_that, int_curr_symbol содержит любой соответствующий разделитель, так что Вы никогда не должны печатать дополнительный пробел.
Мы рекомендуем, чтобы Вы игнорировали эти элементы при печати международных символов валюты и не печатали никаких дополнительных пробелов.
Эти элементы структуры struct lconv определяют, как печатать знак в валютном значении.
char *positive_sign
char *negative_sign
В стандарте "C", оба этих элемента имеет значение "" (пустая строка), означая "неопределенный".
Стандарт ANSI не говорит, что делать, когда Вы находите это значение; мы рекомендуем печатать positive_sign. Для отрицательного значения, печатайте negative_sign, если Вы находите его, если оно и positive_sign пусты, тогда печатайте "-" взамен. (Не указывать знак вообще - кажется довольно неблагоразумным.)
char p_sign_posn
char n_sign_posn
0 Символ валюты и количество должны быть окружены круглыми скобками.
1 Печатает строку перед символом валюты и количеством.
2 Печатает строку после символа валюты и количества.
3 Печатает строку сразу перед символом валюты.
4 Печатает строку сразу за символом валюты.
Иногда, когда ваша программа обнаруживает необычную ситуацию внутри глубоко вложенного набора обращений к функциям, Вы можете захотеть немедленно возвратиться к внешнему уровню управления. Этот раздел описывает, как делать такие нелокальные выходы, используя setjmp и longjmp функции.
Вот пример ситуации, где нелокальный выход может быть полезен: предположим, Вы имеете интерактивную программу, которая имеет "основной цикл" который запрашивает и выполняет команды. Предположите, что команда "read" читает ввод из файла, делая некоторый лексический анализ и анализируя ввод. Если входная ошибка низкого уровня обнаружена, то было бы полезно возвратиться немедленно в " основной цикл " вместо того, чтобы иметь необходимость делать лексический анализ, синтаксический анализ, и все фазы обработки, которые должны явно иметь дело с ситуациями ошибки, первоначально обнаруженными вложенными обращениями.
Некоторым образом нелокальный выход подобен использованию "return", чтобы возвратиться из функции. Но в то время как "return" отказывается только от обращения, пересылая управление обратно к функции, из которой оно вызывалось, нелокальный выход может потенциально отказываться от многих уровней вложенных обращений к функциям.
Вы определяете куда возвращать управление при нелокальных выходах, вызывая функцию setjmp. Эта функция сохраняет информацию относительно среды выполнения, в которой появляется обращение к setjmp в объекте типа jmp_buf. После обращения к setjmp выполнение программы продолжается как обычно, но если позже вызывается longjmp с соответствующим объектом jmp_buf, управление передается обратно в то место, где вызывалась setjmp. Возвращаемое значение из setjmp используется, чтобы отличить обычный возврат и возврат, сделанный обращением к longjmp, так что обращения к setjmp обычно появляются в ` if '.
Вот пример программы, описанный выше:
#include <setjmp.h>
#include <stdlib.h>
#include <stdio.h>
jmp_buf main_loop;
void
abort_to_main_loop (int status)
{
longjmp (main_loop, status);
}
int
main (void)
{
while (1)
if (setjmp (main_loop))
puts ("Back at main loop....");
else
do_command ();
}
void
do_command (void)
{
char buffer[128];
if (fgets (buffer, 128, stdin) == NULL)
abort_to_main_loop (-1);
else
exit (EXIT_SUCCESS);
}
Способ управления внутри функции main может показаться сначала немного таинственным, но это - фактически общая идиома для setjmp. Нормальное обращение к setjmp возвращает нуль, так что "else"-часть условного выражения выполнена. Если abort_to_main_loop вызывается где-нибудь внутри выполнения команды do, то это фактически действует как будто обращение к setjmp в main возвращалось со значением -1.
Так, общий шаблон для использования setjmp выглядит вроде:
if (setjmp (buffer))
/* Код, для выполнения после
преждевременного возврата. */
. . .
else
/* Код, который будет
выполнен после обычной установки
возвращающей отметки. */
. . .
Имеются некоторые подробности относительно функций и структур данных, используемых для выполнения нелокальных выходов.
Эти средства объявлены в " setjmp.h ".
jmp_buf (тип данных)
Содержимое jmp_buf идентифицирует конкретное место возвращения.
int setjmp (jmp_buf state) (макрос)
void longjmp (jmp_buf state, int value)
Имеется множество неизвестных, но важных ограничений на использование setjmp и longjmp. Большинство этих ограничений присутствует, потому что нелокальные выходы требуют некоторых волшебных свойств от части компилятора Cи и могут взаимодействовать с другими частями языка странными способами. setjmp - фактически макрокоманда без определения функции, так что Вы не должны пробовать к " #undef " ее или брать адрес. Кроме того, обращения к setjmp безопасны в только следующих контекстах:
Вы должны использовать в longjmp аргумент отличный от нуля. То что longjmp отказывается передавать обратно аргумент нуля как возвращаемое значение из setjmp, предназначено для безопасности при случайном неправильном употреблении и не является хорошим стилем программирования.
Когда Вы выполняете нелокальный выход, все доступные объекты сохраняют любые значения, которые они имели во время вызова longjmp. Исключение - значения динамических локальных переменных, локальных для функции, содержащей обращение к setjmp, будут изменены и начиная с обращения на setjmp являются неопределенными, если Вы не объявили их отдельно.
В системах UNIX BSD, setjmp и longjmp также сохраняют и восстанавливают набор блокированных сигналов; см. Раздел 21.7 [Блокирование Сигналов]. Однако, POSIX.1 стандарт требует чтобы setjmp и longjmp не изменяли набор блокированных сигналов, и обеспечивает дополнительную пару функций (sigsetjmp и sigsetjmp) чтобы получить поведение BSD функций.
Поведение setjmp и longjmp в библиотеке GNU управляется макрокомандами теста возможностей; см. Раздел 1.3.4 [Макрокоманды Проверки Возможностей]. Значение по умолчанию в системе GNU POSIX.1 поведение, а не поведение BSD.
Средства в этом разделе объявлены в заглавном файле " setjmp.h ".
sigjmp_buf (тип данных)
int sigsetjmp (sigjmp_buf state, int savesigs) (функция)
void siglongjmp (sigjmp_buf state, int value) (функция)
Сигнал - программное прерывание процесса. Операционная система использует сигналы, чтобы сообщить исключительные ситуации выполняемой программе. Некоторые сигналы сообщают об ошибках типа ссылок к недопустимым адресам памяти; другие сообщают асинхронные события, типа разъединения телефонной линии.
Библиотека GNU C определяет ряд типов сигналов, каждый для конкретного вида события. Некоторые виды событий делают нецелесообразным или невозможным обычное продолжение программы, и соответствующие сигналы обычно прерывают программу. Другие виды сигналов сообщают о безобидных событиях, и игнорируются по умолчанию.
Если Вы ожидаете событие, которое вызывает сигналы, Вы можете определить функцию-обработчик и сообщить операционной системе, чтобы она выполнила ее, когда придет заданный тип сигнала.
В заключение нужно сказать, что один процесс может посылать сигнал другому процессу; это позволяет родительскому процессу прерывать дочерние, или сообщаться и синхронизироваться двум связанным процессам.
Этот раздел объясняет базисные понятия того, как сгенерированы сигналы, что случается после получения сигнала, и как программы могут обрабатывать сигналы.
Сигнал сообщает об исключительном событии. Вот - некоторые из событий, которые могут вызывать (или генерировать) сигнал:
Каждый из этих видов событий (за исключением явных обращений, чтобы уничтожать и вызывать) генерирует собственный вид сигнала. Различные виды сигналов перечислены и описываются подробно в Разделе 21.2 [Стандартные Сигналы].
Вообще, события, которые генерируют сигналы, относятся к трем главным категориям: ошибки, внешние события, и явные запросы.
Ошибки означают, что программа сделала кое-что недопустимое и не может продолжать выполнение. Но не все виды ошибок генерируют сигналы фактически, как раз наоборот. Например, открытие несуществующего файла - ошибка, но она не вызывает сигнал; взамен, open возвращает -1. Вообще, ошибки, которые обязательно связаны с некоторыми библиотечными функциями, сообщаются возвратом значения, которое указывает ошибку. Ошибки, которые вызывают сигналы могут случаться где-нибудь в программе, а не только в вызовах из библиотек. Они включают деление на нуль и недопустимые адреса памяти.
Явный запрос означает использование библиотечной функции типа kill, чья цель - специально генерировать сигнал.
Сигналы могут быть сгенерированы синхронно или асинхронно. Синхронный сигнал относится к специфическому действию в программе, и вызывается (если не блокирован) в течение этого действия.
Асинхронные сигналы сгенерированы снаружи при контроле над процессом, который получает их. Эти сигналы занимают непредсказуемое время в течение выполнения. Внешние события генерируют сигналы асинхронно, и так делают явные запросы, которые обращаются к некоторому другому процессу.
Данный тип сигнала является обычно синхронным или асинхронным. Например, сигналы для ошибок обычно синхронны. Но любой тип сигнала может быть сгенерирован синхронно или асинхронно с явным запросом.
Когда сигнал сгенерирован, он откладывается. Обычно он задерживается на короткий период времени и потом передаеся процессу. Однако, если этот вид сигнала в настоящее время блокирован, он может оставаться отложенным, пока сигнал этого вида не откроют. Если только он откроется, он будет передан немедленно. См. Раздел 21.7 [Блокированные Сигналы].
Когда сигнал - передан, или сразу же или после задержки, выполняется заданное действие для этого сигнала. Для некоторых сигналов, типа SIGKILL и SIGSTOP, действие фиксировано, но для большинства сигналов, программа имеет выбор: игнорировать сигнал, определить функцию обработчика, или принять заданное по умолчанию действие для этого вида сигнала. Программа определяет свой выбор используя функции типа signal или sigaction (см. Раздел 21.3 [Действия Сигнала]). Мы иногда говорим, что обработчик захватывает сигнал. В то время как обработчик выполняется, этот специфический сигнал обычно блокируется.
Если заданное действие для вида сигнала - игнорировать его, то любой такой сигнал, будет отброшен немедленно. Это случается, даже если сигнал также блокирован в это время. Сигнал, отброшенный таким образом, передан не будет никогда, даже если программа впоследствии определяет другое действие для этого вида сигнала и откроет его.
Если прибывает сигнал, который программа не обрабатывает, и не игнорирует, происходит заданное по умолчанию действие. Каждый вид сигнала имеет собственное заданное по умолчанию действие, зарегистрированное ниже (см. Раздел 21.2 [Стандартные Сигналы]). Для большинства видов сигналов, заданное по умолчанию действие должно завершить процесс. Для некоторых видов сигналов, которые представляют "безобидные" события, заданное по умолчанию действие должны не делать ничего.
Когда сигнал завершает процесс, родительский процесс может определять причину окончания, исследуя код состояния окончания, сообщенный wait или waitpid функциями. (Это обсуждено более подробно в Разделе 23.6 [Завершение Процесса].) информация, которую он может получать, включает предложение, что окончание было из-за сигнала, и вида включаемого сигнала. Если программа, которую Вы выполняете из оболочки, завершена сигналом, оболочка обычно печатает некоторое сообщение об ошибках.
Сигналы, которые обычно представляют ошибки в программе, имеют специальную особенность: когда один из этих сигналов завершает процесс, он также формирует дамп core-файла, в который записывает состояние процесса во время окончания. Вы можете исследовать core файл отладчиком, чтобы исследовать то, что вызвало ошибку.
Если Вы вызываете сигнал "ошибки в программе" явным запросом, и он завершает процесс, он сделает core-файл, точно как если бы сигнал был непосредственно благодаря ошибке.
Этот раздел перечисляет имена для различных стандартных видов сигналов и описывает какое событие, которое они означают. Каждое имя сигнала - макрокоманда, которая замещает положительное целое число - число сигнала для этого вида сигнала. Ваши программы никогда не должны делать предположения относительно числового кода для специфического вида сигнала, а обращаться к ним всегда именами, определенными здесь. Потому что число для данного вида сигнала может изменяться от системы до системы, но значения имен стандартизированы и довольно однородны.
Имена сигналов определены в заглавном файле " signal.h ".
int NSIG (макрос)
Следующие сигналы сгенерированы, когда операционной системой или компьютером непосредственно обнаружена серьезная ошибка в программе. Вообще, все эти сигналы - индикации, что ваша программа прервана некоторым способом, и не имеется обычно никакого способа продолжить вычисление, которое столкнулось с ошибкой.
Некоторые программы обрабатывают сигналы, возникающие при ошибке в программе, чтобы закончиться логически перед завершением. Обработчик должен завершить работу, определяя заданное по умолчанию действие для сигнала, который случался; это заставит программу завершаться с этим сигналом, как будто без обработчика. (См. Раздел 21.4.2 [Окончание Обработчика].)
Окончание - результат ошибки в программе в большинстве программ. Однако, системы программирования типа Лиспа, могут затем возвратить управление к уровню команды.
Заданное по умолчанию действие для всех этих сигналов должно заставить процесс завершиться. Если Вы блокируете или игнорируете эти сигналы или устанавливаете обработчики для них, которые просто возвращаются, ваша программа возможно пострадает, если сигналы не сгенерированы raise или kill вместо реальной ошибки.
Когда один из этих сигналов об ошибке в программе завершает процесс, он также формирует core-файл, который записывает состояние процесса во время окончания. Файл называется " core " и записан в текущий каталог процесса. (В системе GNU, Вы можете определять имя файла для дампов переменной среды COREFILE.)
Цель core-файлов - чтобы Вы могли исследовать их отладчиком, чтобы найти то, что вызвало ошибку.
int SIGFPE (макрос)
FPE_INTOVF_TRAP
FPE_INTDIV_TRAP
FPE_SUBRNG_TRAP
FPE_FLTOVF_TRAP
FPE_FLTDIV_TRAP
FPE_FLTUND_TRAP
FPE_DECOVF_TRAP
int SIGILL (макрос)
int SIGSEGV (макрос)
int SIGBUS (макрос)
Имя этого сигнала - сокращение для " ошибка шины ".
int SIGABRT (макрос)
Эти сигналы используются, чтобы сообщить, что процесс завершился. Они имеют различные имена, потому что они используются для немного различных целей, и программы могли бы хотеть обрабатывать их по-разному.
Причина обработки этих сигналов - обычно то, что ваша программа должна выполнить некоторые действия перед фактическим завершением. Например, Вы могли бы хотеть сохранять информацию о состоянии, удалить временные файлы, или восстанавливать предыдущие режимы терминала. Такой обработчик должен закончиться определением заданного по умолчанию действия для сигнала, см. раздел 21.4.2 [Окончание Обработчика].) (Очевидное) заданное по умолчанию действие для всех этих сигналов должно заставить процесс завершаться.
int SIGHUP (макрос)
Этот сигнал также используется, чтобы сообщить окончание процесса управления на терминале; это окончание действительно разъединяет все процессы в сеансе с терминалом управления. Для подробной информации см. раздел 22.3.5 [Внутренняя организация Окончания].
int SIGINT (макрос)
int SIGQUIT (макрос)
См. Раздел 21.2.1 [Сигналы Ошибки в программе], для уточнения инфрмации относительно core-файлов. См. Раздел 12.4.9 [Специальные Символы], для уточнения инфрмации относительно поддержки драйвера терминала.
int SIGTERM (макрос)
Команда оболочки kill генерирует SIGTERM по умолчанию.
int SIGKILL (макрос)
Этот сигнал сгенерирован только явным запросом. Так как он не может быть обработан, Вы должны генерировать его только после попытки применения менее сильнодействующего лекарственного средства типа C-c или SIGTERM.
Фактически, если SIGKILL будет не в состоянии завершать процесс, то это ошибка операционной системы, которую Вы должны сообщить.
Эти сигналы используются, чтобы указать окончание времени таймеров. См. Раздел 17.3 [Установка Сигнализаци], для уточнения информации относительно функций, которые заставляют эти сигналы быть посланными.
Заданное по умолчанию поведение для этих сигналов должно вызвать окончание программы. Это значение по умолчанию не очень полезно; но большинство способов использования этих сигналов требовало бы функций обработчика в любом случае.
int SIGALRM (макрос)
Он используется функцией alarm, например.
int SIGVTALRM (макрос)
int SIGPROF (макрос)
Сигналы, перечисленные в этом разделе используются вместе с асинхронными средствами ввода - вывода. Вы должны явно вызвать fcntl, чтобы дать возможность специфическому описателю файла генерировать эти сигналы (см. Раздел 8.12 [Прерывания Ввода]). Заданное по умолчанию действие для этих сигналов - игнорировать их.
int SIGIO (макрос)
В большинстве операционных систем, мониторы и сокеты единственые виды файлов, которые могут генерировать SIGIO; другие виды, включая обычные файлы, никогда не генерируют SIGIO, даже если Вы спрашиваете их.
int SIGURG (макрос)
Эти сигналы используются, чтобы поддерживать управление заданиями. Если ваша система не поддерживает управление заданиями, то эти макрокоманды, определены, но сигналы непосредственно не могут быть вызваны или обрабатываться.
Вы должны вообще оставить эти сигналы, если Вы действительно не понимаете, как управление заданиями работает. См. Главу 24 [Управление заданиями].
int SIGCHLD (макрос)
Заданное по умолчанию действие для этого сигнала - игнорировать это. Если Вы устанавливаете обработчик для этого сигнала, в то время как имеются дочерние процессы, которые завершились, но не сообщили об их состоянии через wait или waitpid (см. Раздел 23.6 [Завершение Процесса]), то применяется ли ваш обработчик к этим процессам или нет зависит от специфической операционной системы.
int SIGCONT (макрос)
Большинство программ не имеет никакой причины обработать SIGCONT; они просто продолжают выполнение без информации, что они когда-либо останавливались. Вы можете использовать обработчик для SIGCONT, чтобы заставить программу сделать нечто специальное, когда она остановлена и продолжиться; например, перепечатывать подсказку, когда она приостановлена при ожидании ввода.
int SIGSTOP (макрос)
int SIGTSTP (макрос)
Ваша программа должна обработать этот сигнал, если Вы имеете специальную потребность оставить файлы или таблицы системы в безопасном состоянии, при остановке процесса. Например, программы, которые выключают отображение на экране, должны обработать SIGTSTP, так чтобы они могли направлять отображение обратно на экран перед остановкой.
Этот сигнал сгенерирован, когда пользователь печатает символ SUSP (обычно C-z). Для получения более подробной информации, см. Раздел 12.4.9 [Специальные Символы].
int SIGTTIN (макрос)
int SIGTTOU (макрос)
В то время когда процесс приостановлен, сигналы не могут быть переданы ему, за исключением сигналов SIGKILL и (очевидно) SIGCONT. Сигнал SIGKILL всегда вызывает окончание процесса и не может быть блокирован или игнорироваться. Вы можете блокировать или игнорировать SIGCONT, но он всегда заставляет процесс быть продолженным во всяком случае, если он остановлен. Посылка сигнала SIGCONT на процесс заставляет любые отложенные сигналы останова для этого процесса быть отброшенными. Аналогично, любая задержка SIGCONT сигнала для процесса отброшена, когда он получает сигнал останова.
Эти сигналы используются, чтобы сообщить некоторые другие условия. Заданное по умолчанию действие для всех из них должно заставить процесс завершиться.
int SIGPIPE (макрос)
Водопроводы и FIFO обсуждены более подробно в Главе 10 [Водопроводы и FIFO].
Другая причина SIGPIPE - когда Вы пробуете выводить на сокет, который не соединен. См. Раздел 11.8.5.1 [Посылка Данных].
int SIGUSR1 (макрос)
int SIGUSR2 (макрос)
Они полезны для межпроцессорной связи. Так как эти сигналы обычно фатальны, Вы должны написать обработчик сигнала для них в программе, которая получает сигнал.
Имеется пример, показывающий использование SIGUSR1 и SIGUSR2 в Разделе 21.6.2 [Передача сигналов Другому Процессу].
Специфические операционные системы поддерживают дополнительные сигналы, не перечисленные выше. Стандарт ANSI C резервирует все идентификаторы, начинающиеся с " SIG " сопровождаемые символом верхнего регистра для имен сигналов. Вам нужно смотреть документацию или заголовочные файлами для вашей конкретной операционной системы и типа процессора, чтобы выяснить какие сигналы поддерживаются.
Например, некоторые системы особо поддерживают сигналы, которые соответствуют аппаратным средствам. Некоторые другие виды сигналов используются, чтобы выполнить ограничения времени CPU или использования файловой системы, для асинхронных изменений конфигурации терминала, и т.п.. Системы могут также определять имена сигналов, которые являются побочными результатами исследований для стандартных имен сигналов.
Заданное по умолчанию действие (или действие, установленное оболочкой) для определенных реализацией сигналов обычно приемлемо. Фактически, обычно не стоит игнорировать или блокировать сигналы, о которых Вы не знаете, или пробовать устанавливать обработчик для сигналов, чьи значения Вы не понимаете.
Вот нгекоторые сигналы, которые обычно используются в операционных системах:
SIGCLD Устаревшее имя для SIGCHLD.
SIGTRAP Сгенерированный командой breakpoint машины. Используется
отладчиками. Заданное по умолчанию действие должно формировать
core-файл.
SIGIOT Сгенерированный PDP-11 "iot" командой; эквивалент SIGABRT.
Заданное по умолчанию действие должно формировать coreфайл.
SIGEMT Ловушка эмулятора; следует из некоторых невыполненных
команд. Это - сигнал ошибки в программе.
SIGSYS Ошибочный системный вызов; то есть команда
системного вызова была выполнена, но код системного вызова
недопустим. Это - сигнал ошибки в программе.
SIGPOLL Это - имя сигнала System V, более или менее подобное SIGIO.
SIGXCPU Превышение ограничения времени CPU. Заданное по
умолчанию действие - окончание программы.
SIGXFSZ Файлом превышено ограничение размера. Заданное по
умолчанию действие - окончание программы.
SIGWINCH Изменение размера окна. Он генерируется на некоторых
системах, когда размер текущего окна на экране изменен.
Заданное по умолчанию действие - игнорировать это.
Мы упомянули выше, что оболочка печатает сообщение, описывающее сигнал, который завершил дочерний процесс. Простой способ печатать сообщение, описывающее сигнал состоит в том, чтобы использовать функции strsignal и psignal. Эти функции используют номер сигнала, чтобы определить, какой вид сигнала описывать. Номер сигнала может исходить из состояния окончания дочернего процесса (см. Раздел 23.6 [Завершение Процесса]) или он может исходить из обработчика сигнала на том же самом процессе.
char * strsignal (int signum) (функция)
Эта функция - расширение GNU, объявленное в заглавном файле "string.h".
void psignal (int signum, const char *message)
Если Вы вызываете psignal с сообщением, которое является или пустым указателем или пустой строкой, psignal печатает сообщение, соответствующее сигналу, добавляя конечный символ перевода строки.
Если Вы обеспечиваете непустой аргумент сообщения, то psignal предворяет вывод этой строкой. Она добавляет двоеточие и пробел, чтобы отделить сообщение от строки, соответствующей сигналу.
Эта функция - возможность BSD, объявленная в заглавном файле "stdio.h ".
Имеется также массив sys_siglist, который содержит сообщения для различных кодов сигнала. Этот массив существует в системах BSD, в отличие от strsignal.
Самый простой способ изменить действие для сигнала состоит в том, чтобы использовать функцию signal. Вы можете определять встроенное действие (типа игнорировать сигнал), или Вы можете устанавливать обработчик.
Библиотека GNU также осуществляет более универсальное средство sigaction. Этот раздел описывает эти средства и дает предложения, когда их использовать.
Функция signal обеспечивает простой интерфейс для установки действия для специфического сигнала.
Функция и связанные макрокоманды объявлены в заголовочном файле "signal.h ".
sighandler_t (тип данных)
void handler (int signum) { . . . }
Функция signal устанавливает action как действие для сигнала signum.
Первый аргумент, signum, идентифицирует сигнал, чьим поведением Вы хотите управлять, и должен быть номером сигнала. Соответствующий способ определять номер сигнала - одним из символических имен сигналов, описанных в Разделе 21.2 [Стандартные Сигналы] не используют явное число, потому что числовой код для данного вида сигнала может измениться от операционной системы к операционной системе.
Второй аргумент, action, определяет действие используемое для сигнала signum. Оно может быть одно из следующих: SIG_DFL определяет заданное по умолчанию действие для специфического сигнала. Заданные по умолчанию действия для различных видов сигналов установлены в Разделе 21.2 [Стандартные Сигналы].
SIG_IGN определяет, что сигнал должен игнорироваться.
Ваша программа вообще не должна игнорировать сигналы, которые представляют серьезные события, или обычно используется, чтобы запросить окончание. Вы не можете игнорировать SIGKILL или SIGSTOP вообще. Вы можете игнорировать сигналы ошибки в программе подобно SIGSEGV, но игнорирование ошибки не будет давать возможность программе продолжить осмысленное выполнение. Игнорирование запросов пользователя типа SIGINT, SIGQUIT, и SIGTSTP некультурно!!.
Когда Вы не желаете, чтобы сигналы были передан в некоторую части программы, нужно блокировать их, а не игнорировать. См. Раздел 21.7 [Блокированные Сигналы]. handler обеспечивает адрес функции обработчика в вашей программе, выполнение этого обработчика определяется как способ передать сигнал.
Для получения более подробной информации относительно функции обработчика сигнала, см. Раздел 21.4 [Определение Обработчиков].
Функция signal возвращает action, который был задан для указанного signum. Вы можете сохранять это значение и восстанавливать его позже, вызывая signal снова.
Если signal не может выполнить запрос, она возвращает SIG_ERR. Следующие errno условия ошибки определены для этой функции:
Вы определили недопустимый signum; или Вы пробовали игнорировать или обеспечивать обработчик для SIGKILL или SIGSTOP.
#include <signal.h>
void
termination_handler (int signum)
{
struct temp_file *p;
for (p = temp_file_list; p; p = p->next)
unlink (p->name);
}
int
main (void)
{
. . .
if (signal (SIGINT, termination_handler)
== SIG_IGN)
signal (SIGINT, SIG_IGN);
if (signal (SIGHUP, termination_handler)
== SIG_IGN)
signal (SIGHUP, SIG_IGN);
if (signal (SIGTERM, termination_handler)
== SIG_IGN)
signal (SIGTERM, SIG_IGN);
. . .
}
Мы не обрабатываем SIGQUIT или сигналы ошибки в программе в этом примере, потому что они разработаны, чтобы обеспечить информацию для отладки (core-файл), и временные файлы могут давать полезную информацию.
sighandler_t ssignal (int signum, sighandler_t action) (функция)
sighandler_t SIG_ERR (макрос)
Функция sigaction имеет тот же самый основной эффект как signal: определять, как сигнал должен быть обработан процессом. Однако, sigaction предлагает большое количество управления, за счет большего количества сложности. В частности sigaction позволяет Вам определять дополнительные флаги, чтобы управлять тем, когда генерируется сигнал и как вызывается обработчик.
Функция sigaction объявлена в "signal.h".
struct sigaction (тип данных)
sighandler_t sa_handler
sigset_t sa_mask
int sa_flags
int sigaction (int signum, const struct sigaction *action, struct sigaction *old_action)
Возвращаемое значение от sigaction - нуль, если она преуспевает, и -1 при отказе. Следующие errno условия ошибки определены для этой функции:
аргумент signum не допустим, или Вы пробуете обрабатывать или игнорировать SIGKILL или SIGSTOP.
Возможно использовать signal и sigaction внутри одной программы, но Вы должны быть внимательным, потому что они могут взаимодействовать немного странными способами.
Функция sigaction определяет более подробную информацию, чем функция signal, так что возвращаемое значение из signal не может выражать все возможности sigaction. Следовательно, если Вы используете signal, чтобы сохранить и позже восстанавливать действие, она может быть не способна восстановить правильно обработчик, который был установлен с sigaction.
Чтобы избежать проблем всегда используйте sigaction, чтобы сохранить и восстановить обработчик, если ваша программа использует sigaction вообще. Так как sigaction более общая, она может правильно сохранять и восстанавливать любое действие, независимо от того, было ли оно установлено первоначально с signal или sigaction.
Если Вы устанавливаете действие с signal, а потом исследуете его sigaction, адрес обработчика, который Вы получаете, может быть не такой же как тот, что Вы определили с signal. Он так же не может использоваться как аргумент action в signal. Но Вы можете полагаться на использование его как аргумента sigaction.
Так что лучше отказаться от использования того и другого механизма последовательно внутри однй программы.
Примечание о переносимости: общая функция сигнала - возможность ANSI C, в то время как sigaction - часть POSIX.1 стандарта. Если Вы беспокоитесь относительно переносимости на не-posix системы, то Вы должены использовать функцию signal.
В Разделе 21.3.1 [Общая Обработка сигнала], мы привели пример установки простого обработчика для сигналов окончания, используя signal. Вот эквивалентный пример, использующий sigaction:
#include <signal.h>
void
termination_handler (int signum)
{
struct temp_file *p;
for (p = temp_file_list; p; p = p->next)
unlink (p->name);
}
int
main (void)
{
. . .
struct sigaction new_action, old_action;
new_action.sa_handler = termination_handler;
sigemptyset (&new_action.sa_mask);
new_action.sa_flags = 0;
sigaction (SIGINT, NULL, &old_action);
if (old_action.sa_handler != SIG_IGN)
sigaction (SIGINT, &new_action, NULL);
sigaction (SIGHUP, NULL, &old_action);
if (old_action.sa_handler != SIG_IGN)
sigaction (SIGHUP, &new_action, NULL);
sigaction (SIGTERM, NULL, &old_action);
if (old_action.sa_handler != SIG_IGN)
sigaction (SIGTERM, &new_action, NULL);
. . .
}
В примере, использующем signal, мы старались избегать обрабатывать предварительно установленные сигналы. Здесь мы можем мгновенно избегать изменять обработчик сигнала, используя возможность sigaction, которая позволяет исследовать текущее действие без определения нового.
Вот другой пример. Он отыскивает информацию относительно текущего действия для SIGINT без замены этого действия.
struct sigaction query_action;
if (sigaction (SIGINT, NULL, &query_action) < 0)
/* sigaction возвращает -1 в случае ошибки. */
else if (query_action.sa_handler == SIG_DFL)
/* SIGINT обработан заданным по умолчанию,
фатальным способом. */
else if (query_action.sa_handler == SIG_IGN)
/ * SIGINT игнорируется. * /
else
/* Определенный программистом
обработчик сигнала. */
элемент структуры sa_flags - sigaction определяет специальные возможности. В большинстве случаев, SA_RESTART - хорошее значение, чтобы использовать для этого поля.
Значение sa_flags интерпретируется как битовая маска. Таким образом, Вы должны выбрать флаги, которые Вы хотите установить, сделать операцию OR для этих флагов, и сохранить результат в sa_flags элементе вашей структуры sigaction.
Каждый номер сигнала имеет собственный набор флагов. Каждое обращение к sigaction воздействует на один номер сигнала, и флаги, которые Вы определяете, применяются только к этому специфическому сигналу.
В библиотеке GNU C, установка обработчика сигнала обнуляет все флаги, кроме SA_RESTART, чье значение зависит от установок, которые Вы сделали в siginterrupt. См. Раздел 21.5 [Прерванные Примитивы].
Эти макрокоманды определены в заголовочном файле " signal.h ".
int SA_NOCLDSTOP (макрос)
При установке этого флага для сигнала отличного от SIGCHLD не имеет никакого эффекта.
int SA_ONSTACK (макрос)
int SA_RESTART (макрос)
Выбор управляется SA_RESTART флагом для конкретного вида сигнала, который был передан. Если флаг установлен, по возвращении из обработчика продолжается библиотечная функция. Если флаг не установлен, происходит сбой функции. См. Раздел 21.5 [Прерванные Примитивы].
После создания, новый процесс (см. Раздел 23.4 [Создание Процесса]) наследует обработку сигналов из родительского процесса. Однако, когда Вы загружаете новый образ процесса, используя функцию exec (см. Раздел 23.5 [Выполнение Файла] ) обработчики любых сигналов возвращаются к SIG_DFL. Конечно, новая программа может устанавливать собственные обработчики.
Когда программа выполняется оболочкой, оболочка обычно устанавливает начальные действия для дочернего процесса как SIG_DFL или SIG_IGN, соответственно.
Вот пример того, как устанавливать обработчик для SIGHUP, но если SIGHUP в настоящее время не игнорируется:
. . .
struct sigaction temp;
sigaction (SIGHUP, NULL, &temp);
if (temp.sa_handler != SIG_IGN)
{
temp.sa_handler = handle_sighup;
sigemptyset (&temp.sa_mask);
sigaction (SIGHUP, &temp, NULL);
}
Этот раздел описывает, как написать функцию обработчика сигнала, которая может быть установлена функциями sigaction или signal.
Обработчик сигнала - функция, которую Вы компилируете вместе с остальной частью программы. Вместо непосредственно вызова функции, Вы используете signal или sigaction, чтобы сообщить, чтобы операционная система вызвала ее, когда приходит сигнал. Это называется установкой обработчика. См. Раздел 21.3 [Действия Сигнала].
Имеются две cтратегии, которые Вы можете использовать в функциях обработчика сигнала:
Обработчики, которые возвращаются обычно используются для сигналов типа SIGALRM и ввода-вывода и межпроцессорных сигналов связи. Но обработчик для SIGINT может также возвращаться после установки флага, который сообщает, чтобы программа завершилась в удобное время.
Небезопасно возвращаться из обработчика при сигнале ошибки в программе, потому что поведение программы, когда функция обработчика возвращается, не определено после ошибки в программе. См. Раздел 21.2.1 [Сигналы Ошибки в программе].
Обработчики, которые возвращаются, должны изменять некоторую глобальную переменную, чтобы иметь какой-нибудь эффект.
Обычно, эта переменная исследуется периодически программой. Тип данных должен быть sig_atomic_t по причинам, описанным в Разделе 21.4.7 [Быстрый Доступ к данным].
Вот простой пример такой программы. Она выполняет тело цикла, пока она не отметит, что сигнал SIGALRM прибыл.
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
volatile sig_atomic_t keep_going = 1;
void
catch_alarm (int sig)
{
keep_going = 0;
signal (sig, catch_alarm);
}
void
do_stuff (void)
{
puts ("Doing stuff while waiting
for alarm....");
}
int
main (void)
{
signal (SIGALRM, catch_alarm);
alarm (2);
while (keep_going)
do_stuff ();
return EXIT_SUCCESS;
}
Функции-Обработчики, которые завершают программу, обычно используются, чтобы вызвать организованную очистку от сигналов ошибки в программе и интерактивных прерываний.
Самый чистый способ для обработчика завершить процесс состоит в том, чтобы вызвать тот же самый сигнал, который активизировал обработчик. Вот, как сделать это:
volatile sig_atomic_t fatal_error_in_progress = 0;
void
fatal_error_signal (int sig)
{
if (fatal_error_in_progress)
raise (sig);
fatal_error_in_progress = 1;
/ * Теперь делаем очищающие действия:
- установка режимов терминала
- уничтожение дочерних процессов
- удаление временных файлов * /
. . .
raise (sig);
}
Вы можете делать нелокальную передачу управления вне обработчика сигнала, используя setjmp и longjmp средства (см. Главу 20 [Нелокальные Выходы]).
Когда обработчик делает нелокальную передачу управления, часть программы, которая выполнялась, не будет продолжаться. Если эта часть программы была в процессе изменения важной структуры данных, структура данных останется несогласованной. Так как программа не завершается, несогласованность должна быть отмечена позже.
Имеются два способа избежать этой проблемы. Первый - блокировать сигнал для частей программы, которые изменяют важные структуры данных. Блокирование сигнала задерживает выдачу, пока он не открыт, как только критическое изменение закончено. См. Раздел 21.7 [Блокированные Сигналы].
Иначе, нужно повторно инициализировать определяющие структуры данных в обработчике сигнала, или сделать их значения непротиворечивыми.
Вот довольно схематический пример, показывающий переинициализацию одной глобальной переменной.
#include <signal.h>
#include <setjmp.h>
jmp_buf return_to_top_level;
volatile sig_atomic_t waiting_for_input;
void
handle_sigint (int signum)
{
waiting_for_input = 0;
longjmp (return_to_top_level, 1);
}
int
main (void)
{
. . .
signal (SIGINT, sigint_handler);
. . .
while (1) {
prepare_for_command ();
if (setjmp (return_to_top_level) == 0)
read_and_execute_command ();
}
}
char *
read_data ()
{
if (input_from_terminal) {
waiting_for_input = 1;
. . .
waiting_for_input = 0;
}
else {
. . .
}
}
Что случается, если другой сигнал приходит, когда выполняется ваша функция обработчика сигнала?
Когда вызывается обработчик для конкретного сигнала, этот сигнал обычно блокируется, пока обработчик не возвращается. Это означает что, если два сигнала того же самого вида приходят через очень короткий интервал времени, второй будет приостановлен, пока первый не будет обработан. (Обработчик может явно открыть сигнал, используя sigprocmask, если Вы хотите позволить прибывать большему количеству сигналов этого типа; см. Раздел 21.7.3 [Маска Сигнала Процесса].)
Однако, ваш обработчик может все еще прерываться получением другого вида сигнала. Чтобы избежать этого, Вы можете использовать sa_mask - элемент структуры action, передаваемой sigaction, чтобы явно определить, какие сигналы должны быть блокированы в то время как обработчик сигнала выполняется. См. Раздел 21.7.5 [Блокирование для Обработчика].
Примечание о переносимости: Всегда используйте sigaction, чтобы установить обработчик для сигнала, который Вы ожидаете получать асинхронно, если Вы хотите, чтобы ваша программа работала правильно на System V Unix.
Если несколько сигналов того же самого типа переданы вашему процессу прежде, чем ваш обработчик сигнала может быть вызван вообще, то обработчик может вызываться только один раз, как будто только одиночный сигнал прибыл. В результате сигналы обьединяются в один. Эта ситуация может возникать, когда сигнал блокирован, или в многопроцессорной среде, где система - занята выполнением некоторых других процессов, в то время как сигналы - передан. Это означает, например, что Вы не можете надежно использовать обработчик сигнала, чтобы считать сигналы. Единственное, что Вы можете сделать узнать, прибыл ли по крайней мере один сигнал начиная с данного времени.
Вот пример обработчика для SIGCHLD, который компенсирует предложение, что число полученных сигналов не может равняться числу дочерних процессов, генерируя их. Он подразумевает, что программа следит за всеми дочерними процессами цепочкой структур следующим образом:
struct process
{
struct process *next;
int pid;
int input_descriptor;
int status;
};
struct process *process_list;
int process_status_change;
void
sigchld_handler (int signo)
{
int old_errno = errno;
while (1) {
register int pid;
int w;
struct process *p;
do
{
errno = 0;
pid = waitpid (WAIT_ANY,
&w,
WNOHANG | WUNTRACED);
}
while (pid <= 0 && errno == EINTR);
if (pid <= 0) {
errno = old_errno;
return;
}
for (p = process_list; p; p = p->next)
if (p->pid == pid) {
p->status = w;
p->have_status = 1;
if (WIFSIGNALED (w) ||
WIFEXITED (w))
if (p->input_descriptor)
FD_CLR (p->input_descriptor, &input_wait_mask);
++process_status_change;
}
}
}
if (process_status_change) {
struct process *p;
process_status_change = 0;
for (p = process_list; p; p = p->next)
if (p->have_status) {
... Исследуют p->status ...
}
}
Цикл, который проверяет состояние процесса избегает исследовать p->status, пока он не видит, что состояние было законно сохранено. Он должен удостовериться, что status не может изменяться в середине доступа к нему. Как только p->have_status установлен, это означает что дочерний процесс остановлен или завершен, и в любом случае он не может останавливаться или завершаться снова. См. Раздел 21.4.7.3 [Быстрое Использование], для получения более подробной информации относительно копирования с прерываниями во время доступов к переменной.
Вот, таким образом Вы можете проверять, выполнился ли обработчик начиная с последней проверки.
Эта методика использует счетчик, который никогда не изменяется снаружи обработчика. Вместо того, чтобы очищать счетчик, программа помнит предыдущее значение, и видит, изменилось ли оно начиная с предыдущей проверки. Преимущество этого метода - в том, что различные части программы могут проверять независимо, каждая часть проверяет имелся ли сигнал начиная с последней проверки в этой части.
sig_atomic_t process_status_change;
sig_atomic_t last_process_status_change;
. . .
{
sig_atomic_t prev=last_process_status_change;
last_process_status_change =
process_status_change;
if (last_process_status_change != prev) {
struct process *p;
for (p = process_list; p; p = p->next)
if (p->have_status) {
... Проверка p->status ...
}
}
}
Функции-Обработчики обычно делают не очень много. Самый лучший обработчик - который не делает ничего, но устанавливает внешнюю переменную, которую программа проверяет регулярно, и оставляет всю серьезную работу программе. Это самое лучшее, потому что обработчик может вызываться асинхронно, в непредсказуемое время, возможно в середине системного вызова, или даже между началом и концом оператора Cи, который требует выполнения многократных команд. Изменяемые структуры данных могут быть в несогласованном состоянии, когда вызывается функция обработчика. Даже копирование одной int переменной в другую занимает две команды на большинстве машин.
Это означает, что Вы должны быть очень осторожын относительно того, что Вы делаете в обработчике сигнала.
Для любого вида данных в вашем приложении, Вы должны быть внимательны к тому, что доступ к одиночному элементу данных не обязательно быстрый. Это означает, что это может занимать больше чем одну команду. В таких случаях, обработчик сигнала может выполняться в середине чтения или запииси объекта.
Имеются три способа, при помощи которых Вы можете справляться с этой проблемой. Вы можете использовать типы данных, к которым всегда обращаются быстро; Вы можете тщательно упорядочивать их, так что ничего неблагоприятного не случается, если доступ прерван, или Вы можете блокировать все сигналы вокруг любого доступа, который лучше не прерывать (см. Раздел 21.7 [Блокированные Сигналы]).
Вот пример, который показывает то, что может случиться, если обработчик сигнала выполняется в середине изменения переменной. (Прерывание чтения переменной может также привести к парадоксальным результатам, но здесь мы показываем только запиись.)
#include <signal.h>
#include <stdio.h>
struct two_words { int a, b; } memory;
void
handler(int signum)
{
printf ("%d,%d\n", memory.a, memory.b);
alarm (1);
}
int
main (void)
{
static struct two_words zeros = {0,0},
ones = {1,1};
signal (SIGALRM, handler);
memory = zeros;
alarm (1);
while (1)
{
memory = zeros;
memory = ones;
}
}
Ясно, эта программа может печатать пару нулей или пару едениц. Но это - не все что она может делать! На большинстве машин сохранение нового значения в памяти занимает несколько команд, и значение сохраняется по одному слову. Если сигнал передан между этими командами, обработчик, может находить, что memory.a - нуль, а memory.b - один (или наоборот).
На некоторых машинах может быть возможно сохранить новое значение в памяти только одной командой, которая не может быть прервана. На этих машинах, обработчик будет всегда печатать два нуля или две еденицы.
Чтобы избегать неопределенности относительно прерывания доступа к переменной, Вы можете использовать специфический тип данных, для которого доступ является всегда быстрым: sig_atomic_t. При чтении и запииси этого типа данных, как гарантируется, выполняется одиночная команда, так что не имеется никакого способа для обработчика, чтобы выполниться "в середине " доступа.
Тип sig_atomic_t - всегда целочисленный тип данных, но сколько битов он содержит, может изменяться от машины до машины.
sig_atomic_t
Практически, Вы можете считать, что int и другие целочисленные типы не большие, чем int - быстрые.
Вы можете также считать, что к типам pointer быстрый доступ; это очень удобно. Оба этих утверждения верны для всех машин, которые поддерживает библиотека GNU C, и на всех системах POSIX, о которых мы знаем.
Некоторые шаблоны доступа избегают любой проблемы, даже если доступ прерван. Например, флаг, который установлен обработчиком, и проверяется и очищается программой main время от времени, всегда безопасен, даже если доступ к нему фактически требует двух команд. Чтобы показать, что это так, мы должны рассмотреть каждый доступ, который мог быть прерван, и показывать, что не имеется никакой проблемы, если он прерван.
Прерывание в середине тестирования флага безопасно, потому что либо он распознан отличным от нуля, тогда точное значение не важно, либо он будет отличным от нуля, в следующий раз.
Прерывание в середине очистки флага не проблема, потому что либо программа записывает нуль, если сигнал входит прежде, чем флаг очищен, либо обрабтчик заканчивается, и последующие события происходят при флаге отличном от нуля.
Если код обрабатывает оба этих случая правильно, то он может также обрабатывать сигнал в середине очистки флага.
Иногда Вы можете обеспечивать непрерывный доступ к одному объекту, защищая его использование другим объектом, возможно тем, чей тип гарантирует быстроту. См. Раздел 21.4.5 [Обьединенные Сигналы].
Сигнал может прибывать и обрабатываться, в то время как примитив ввода - вывода типа open или read ждет устройство ввода - вывода. Если обработчик сигнала возвращается, система задает вопрос: что должно случиться затем?
POSIX определяет один подход: делайте примитивный сбой сразу же. Код ошибки для этого вида отказа - EINTR. Это гибко, но обычно неудобно. Обычно, приложения POSIX, которые используют обработчики сигнала, должны проверить EINTR после каждой библиотечной функции, которая может возвращать его, чтобы пытаться обратиться снова. Часто программисты забывают это проверять, что является общим источником ошибок.
Библиотека GNU обеспечивает удобный способ повторить обращение после временного отказа макрокомандой TEMP_FAILURE_RETRY:
TEMP_FAILURE_RETRY (expression) (макрос)
Значение, возвращенное TEMP_FAILURE_RETRY - любое произведенное выражением значение.
BSD избегает EINTR полностью и обеспечивает более удобный подход: перезапускать прерванный примитив. Если Вы выбираете этот подход, Вы не нуждаетесь в EINTR.
Вы можете выбирать любой подход в библиотеке GNU. Если Вы используете sigaction, чтобы установить обработчик сигнала, Вы можете определять, как этот обработчик должен вести себя. Если Вы определяете SA_RESTART флаг, после возврата из этого обработчика продолжится примитив; иначе, возврат из этого обработчика вызовет EINTR. См. Раздел 21.3.5 [Флаги для Sigaction].
Другой способ определять выбор - siginterrupt функцией. См. Раздел 21.9.1 [POSIX против BSD].
Когда Вы не определяете с sigaction или siginterrupt, что специфический обработчик должен делать, он использует заданный по умолчанию выбор. Заданный по умолчанию выбор в библиотеке GNU зависит от возможностей макрокоманд, которые Вы определили. Если Вы определяете _BSD_SOURCE или _GNU_SOURCE перед вызовом сигнала, значение по умолчанию - продолжить примитивы; иначе, значение по умолчанию должно делать сбой с EINTR. (Библиотека содержит альтернативные версии функции signal, и макрокоманды возможностей определяют, которую Вы действительно вызываете.) См. Раздел 1.3.4 [Макрокоманды Возможностей].
Примитивы, на которые воздействует это: close, fcntl (операция F_SETLK), open, read, recv, recvfrom, select, send, sendto, tcdrain, waitpid, wait, и write.
Имеется одна ситуация, где возобновление никогда не случается, независимо от того, какой выбор Вы делаете: когда функция преобразования типа например read или write прервана сигналом после пересылки части данных. В этом случае, функция возвращает число байтов, уже перемещенных, указывая частичный успех.
Это может вызвать ненадежное поведение на устройствах для записи (включая датаграммный сокет; см. Раздел 11.9 [Датаграммы]), при разбивании одного чтения или записи на два чтения или две записи для двух единиц. Фактически, не имеется никакой проблемы, потому что прерывание после частичной передачи не может случаться на таких устройствах; они всегда передают всю запись в одном пакете, без ожидания, если только передача данных началась.
Кроме сигналов, которые сгенерированы в результате аппаратной проверки или прерывания, ваша программа может явно посылать сигналы себе или другому процессу.
Процесс может посылать себе сигнал функцией raise. Эта функция объявлена в "signal.h".
int raise (int signum)
int gsignal (int signum)
Удобное использование raise - воспроизвести заданное по умолчанию поведение сигнала, который Вы обработали. Например, предположите, что пользователь вашей программы печатает символ SUSP (обычно C-z; см. Раздел 12.4.9 [Специальные Символы]) чтобы послать интерактивный сигнал останова (SIGTSTP), и Вы хотите очистить некоторые внутренние буфера данных перед остановкой. Вы можете сделать это примерно так:
#include <signal.h>
void
tstp_handler (int sig)
{
signal (SIGTSTP, SIG_DFL);
. . .
raise (SIGTSTP);
}
void
cont_handler (int sig)
{
signal (SIGCONT, cont_handler);
signal (SIGTSTP, tstp_handler);
}
int
main (void)
{
signal (SIGCONT, cont_handler);
signal (SIGTSTP, tstp_handler);
. . .
}
Функция kill может использоваться, чтобы послать сигнал другому процессу. Несмотря на имя, она может использоваться для множества вещей отличных от завершения процесса. Вот некоторые примеры ситуаций, где Вы могли бы хотеть посылать сигналы между процессами:
int kill (pid_t pid, int signum) (функция)
Процесс, чей идентификатор - pid.
Все процессы в той же самой группе что и отправитель. Отправитель непосредственно не получает сигнал.
Группа процесса, чей идентификатор есть -pid.
Если процесс привилегирован, посылает сигнал всем процессам, кроме некоторых специальных процессов системы. Иначе, посылает сигнал всем процессам с тем же самым эффективным ID пользователя.
kill (getpid (), signum).
Возвращаемое значение из kill - нуль, если сигнал может быть послан успешно. Иначе, никакой сигнал не послан, и возвращается значение -1. Если pid определяет посылку сигнала отдельным процессам, kill успешно завершается, если он может посылать сигнал по крайней мере одному из них. Не имеется никакого способа, которым Вы можете узнать, который из процессов получил сигнал или что все они получили его.
Следующие errno условия ошибки определены для этой функции:
аргумент signum - недопустимое или неподдерживаемое число.
Вы не имеете привилегий, чтобы послать сигнал процессу или любому из процессов в группе процесса, именованной pid.
id аргумент не относится к существующему процессу или группе.
int killpg (int pgid, int signum) (функция)
Как простой пример kill, обращение kill (getpid (), sig) имеет тот же самый эффект как raise (sig).
Имеются ограничения, которые запрещают Вам использовать kill, чтобы послать сигнал любому процессу.
Они предназначены, чтобы предотвратить антиобщественное поведение типа произвольного уничтожения процессов, принадлежащих другому пользователю. Обычно, kill используется, чтобы передать сигналы между родителем и дочерним процессами, или процессами братьями, и в этих ситуациях Вы обычно имеете право послать сигнал. Единственное общее исключение - когда Вы выполняете программу setuid на дочернем процессе; если программа изменяет реальный UID также как эффективный UID, Вы не можете иметь право, чтобы послать сигнал. Программа su делает это.
Имеет ли процесс право, чтобы послать сигнал другому процессу, определяется пользовательскими ID этих двух процессов. Это понятие обсуждено подробно в Разделе 25.2 [Владелец Процесса].
Вообще, чтобы можно было посылать сигнал другому процессу, посылающий процесс должен принадлежать привилегированному пользователю (подобно " root "), или реальный, или эффективный пользовательский ID процесса посылки должен соответствовать реальному, или эффективному пользовательскому ID процесса получения. В некоторых реализациях, родительский процесс способен послать сигнал дочернему процессу, даже если пользовательские ID не соответствуют. Другие реализации, могут предписывать другие ограничения.
Сигнал SIGCONT - частный случай. Он может быть послан, если отправитель - часть того же самого сеанса что и получатель, независимо от пользовательских ID.
Вот более длинный пример, показывающий, как сигналы могут использоваться для межпроцессорной связи. Это то, для чего предусмотрены сигналы SIGUSR1 и SIGUSR2. Так как эти сигналы фатальны по умолчанию, процесс, который, как предполагается, получает их, должен обрабатывать их через signal или sigaction.
В этом примере, родительского процесс порождает дочерний процесс и ждет пока дочерний завершит инициализацию. Дочерний процесс сообщает родителю, когда он готов, посылая ему сигнал SIGUSR1, используя функцию kill.
#include <signal.h>
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
volatile sig_atomic_t usr_interrupt = 0;
void
synch_signal (int sig)
{
usr_interrupt = 1;
}
/* Дочерний процесс выполняет эту функцию. */
void
child_function (void)
{
printf ("I'm here!!! My pid is %d.\n",
(int) getpid ());
kill (getppid (), SIGUSR1);
puts ("Bye, now....");
exit (0);
}
int
main (void)
{
struct sigaction usr_action;
sigset_t block_mask;
pid_t child_id;
sigfillset (&block_mask);
usr_action.sa_handler = synch_signal;
usr_action.sa_mask = block_mask;
usr_action.sa_flags = 0;
sigaction (SIGUSR1, &usr_action, NULL);
/* Создание дочернего процесса. */
child_id = fork ();
if (child_id == 0)
child_function ();
while (!usr_interrupt)
;
puts ("That's all, folks!");
return 0;
}
Блокирование сигнала означает сообщение операционной системе, чтобы задержать его и передать его позже. Вообще, программа просто так не блокирует сигналы, она может также игнорировать их, устанавливая их действия как SIG_IGN. Но полезно блокировать сигналы ненадолго, чтобы предотвратить прерывание чувствительных операций. Например:
Временное блокирование сигналов с sigprocmask дает Вам возможность предотвратить прерывания при выполнении критических частей вашего кода. Если сигналы прибывают в эту часть программы, они будут переданы позже, после того, как Вы откроете их.
Например, это полезно - для совместного использования данных обработчиком сигнала и остальной частью программы. Если тип данных - не sig_atomic_t (см. Раздел 21.4.7 [Быстрый Доступ к данным]), то обработчик сигнала может выполняться, когда остальная часть программы закончила только половину чтения или запииси данных.
Чтобы делать программу надежной, Вы можете предотвращать выполнение обработчика сигнала, в то время как остальная часть программы исследует или изменяет эти данные, блокировав соответствующий сигнал в частях программы, которые касаются данных.
Блокирование сигналов также необходимо, когда Вы хотите выполнить некоторое действие только, если сигнал не прибыл. Предположите, что обработчик для сигнала устанавливает флаг типа sig_atomic_t; Вы хотели бы проверить флаг и выполнить действие, если флаг не установлен. Это ненадежно. Предположите, что сигнал передан немедленно после того, как Вы проверяете флаг, но перед последовательным действием: тогда программа выполнит действие, даже если сигнал прибыл.
Единственый способ проверять, надежно ли прибыл ли сигнал, состоит в том, чтобы проверять это в то время, когда сигнал блокирован.
Все функции блокирования сигнала используют структуру данных называемую набором сигналов, чтобы определить на какие сигналы воздействовать. Таким образом, каждое действие включает две стадии: создание набора сигналов, и передача его как аргумента библиотечной функции.
Эти средства объявлены в заглавном файле " signal.h ".
sigset_t
Для переносимости, чтобы инициализировать, изменять и читать информацию из объектов sigset_t, используйте только функции, описанные в этом разделе, не пробуйте манипулировать ими непосредственно.
Имеются два способа инициализировать набор сигналов. Вы можете первоначально определить его пустыми через sigemptyset и затем добавлять заданные сигналы индивидуально. Или Вы можете определить его полными через sigfillset и тогда удалять заданные сигналы индивидуально.
Вы должны всегда инициализировать набор сигналов одной из этих двух функций перед использованием его любым другим способом. Не пробуйте устанавливать все сигналы явно, потому что объект sigset_t может включать некоторую другую информацию (подобно полю версии) которое должно быть инициализировано также.
int sigemptyset (sigset_t *set)
int sigfillset (sigset_t *set)
int sigaddset (sigset_t *set, int signum)
Возвращаемое значение - 0 при успехе и -1 при отказе. Следующее errno - условие ошибки определено для этой функции:
аргумент знака не определяет допустимый сигнал.
int sigdelset (sigset_t *set, int signum)
В заключение, имеется функция, чтобы проверить то, что сигналы находятся в наборе сигналов:
int sigismember (const sigset_t *set, int signum)
Следующее errno условие ошибки определено для этой функции:
аргумент signum не определяет допустимый сигнал.
Набор сигналов, которые в настоящее время блокированы, называется маской сигналов. Каждый процесс имеет собственную маску сигналов. Когда Вы создаете новый процесс (см. Раздел 23.4 [Создание Процесса]), он наследует маску родителя. Вы можете блокировать или открывать сигналы с большей гибкостью, изменяя маску сигналов.
Прототип для sigprocmask функции находится в " signal.h ".
int sigprocmask (int how, const sigset_t *set, sigset_t *oldset)
SIG_BLOCK
SIG_UNBLOCK
SIG_SETMASK
Последний аргумент, oldset, используется, чтобы возвратить информацию относительно старой маски сигналов процесса. Если Вы хотите только изменять маску без того, чтобы рассмотривать ее, передавайте пустой указатель как oldset аргумент. Аналогично, если Вы хотите знать что находится в маске, без того, чтобы заменить ее, передайте пустой указатель для set. Oldset аргумент часто используется, чтобы запомнить предыдущую маску сигналов, чтобы восстановить ее позже.
Если вызов sigprocmask открывает любые отложенные сигналы, то по крайней мере один из этих сигналов будет передан процессу прежде, чем sigprocmask возвртится. Порядок, в котором передаются отложенные сигналы является не определенным, но Вы можете управлять порядком явно, делая несколько обращений к sigprocmask, чтобы открывать различные сигналы по одному. Sigprocmask функция возвращает 0, если она успешна, и -1, в противном случае. Следующие errno условия ошибки определены для этой функции:
Аргумент how недопустим.
Вот простой пример. Предположите, что Вы устанавливаете обработчик для сигналов SIGALRM, который устанавливает флаг всякий раз, когда прибывает сигнал, и ваша программа main проверяет этот флаг время от времени и сбрасывает его. Вы можете предотвращать прибытие дополнительных сигналов SIGALRM в неподходящее время, ограничивая критическую часть кода обращениями к sigprocmask, примерно так:
sig_atomic_t flag = 0;
int
main (void)
{
sigset_t block_alarm;
. . .
sigemptyset (&block_alarm);
sigaddset (&block_alarm, SIGALRM);
while (1)
{
sigprocmask (SIG_BLOCK, &block_alarm,
NULL);
if (flag)
{
actions-if-not-arrived
flag = 0;
}
sigprocmask (SIG_UNBLOCK, &block_alarm,
NULL);
. . .
}
}
Когда обработчик сигнала вызывается, Вы обычно хотите, чтобы он закончился без прерываний другим сигналом. С момента старта обработчика до момента его окончания, Вы должны блокировать сигналы, которые могли бы запутать его или разрушить данные.
Когда функция обработчика вызывается для сигнала, этот сигнал автоматически блокируется (в дополнение к любым другим сигналам, которые являются уже в маске сигналов процесса) пока обработчик выполняется. Если Вы устанавливаете обработчик для SIGTSTP, например, то поступление этого сигнала, вынуждает дальнейшие SIGTSTP сигналы ждать в течение выполнения обработчика.
Однако, по умолчанию, другие виды сигналов не блокированы; они могут прибывать в течение выполнения обработчика.
Надежный способ блокировать другие виды сигналов в течение выполнения обработчика состоит в том, чтобы использовать sa_mask элемент структуры sigaction.
Вот пример:
#include <signal.h>
#include <stddef.h>
void catch_stop ();
void
install_handler (void)
{
struct sigaction setup_action;
sigset_t block_mask;
sigemptyset (&block_mask);
sigaddset (&block_mask, SIGINT);
sigaddset (&block_mask, SIGQUIT);
setup_action.sa_handler = catch_stop;
setup_action.sa_mask = block_mask;
setup_action.sa_flags = 0;
sigaction (SIGTSTP, &setup_action, NULL);
}
<tscreen><verb> Это более надежно чем блокирование других сигналов явно в коде
обработчика. Если Вы блокируете сигналы в обработчике, Вы не может
избежать по крайней мере короткого интервала в начале обработчика, где
они еще не блокированы.
Вы не можете удалять сигналы из текущей маски процесса, используя
этот механизм. Однако, Вы можете делать обращения к sigprocmask внутри
вашего обработчика, чтобы блокировать или открыть сигналы, как Вы
желаете.
В любом случае, когда обработчик возвращается, система
восстанавливает маску, которая была до обработчика.
<sect2>Прверка Отложенных Сигналов
<p>
Вы можете выяснять, какие сигналы отложены в любое время, вызывая
sigpending. Эта функция объявлена в " signal.h ".
<tscreen><verb> int sigpending (sigset_t *set) (функция)
Возвращаемое значение - 0 при успехе, и -1 при отказе.
Тестирование отложен ли сигнал полезно не часто. Тестирование сигнала который не блокирован - почти всегда бессмысленно.
Вот пример.
#include <signal.h>
#include <stddef.h>
sigset_t base_mask, waiting_mask;
sigemptyset (&base_mask);
sigaddset (&base_mask, SIGINT);
sigaddset (&base_mask, SIGTSTP);
sigprocmask (SIG_SETMASK, &base_mask, NULL);
. . .
sigpending (&waiting_mask);
if (sigismember (&waiting_mask, SIGINT)) {
/* Пользователь пробовал уничтожать процесс. */
}
else if (sigismember (&waiting_mask, SIGTSTP)) {
/*Пользователь пробовал остановить процесс.*/
}
Примечание Переносимости: функция sigpending новая в POSIX.1. Более старые системы не имеют никакого эквивалентного средства.
Вместо того, чтобы блокировать сигнал используя библиотечные средства, Вы можете получить почти те же самые результаты, делая так чтобы обработчик устанавливал флаг, который будет проверен позже, когда Вы "откроете". Вот пример:
volatile sig_atomic_t signal_pending;
volatile sig_atomic_t defer_signal;
void
handler (int signum)
{
if (defer_signal)
signal_pending = signum;
else
... /*"Действительно" обрабатываем сигнал.*/
}
. . .
void
update_mumble (int frob)
{
defer_signal++;
mumble.a = 1;
mumble.b = hack ();
mumble.c = frob;
defer_signal--;
if (defer_signal == 0 && signal_pending != 0)
raise (signal_pending);
}
Мы увеличиваем и уменьшаем defer_signal так, чтобы вложенные критические разделы работали правильно; таким образом, если update_mumble вызывалась с signal_pending, уже отличным от нуля, сигналы будут отсрочены не только внутри update_mumble, но также внутри вызывающего оператора. Вот почему мы не проверяем signal_pending, если defer_signal все еще отличен от нуля.
Приращение и уменьшение defer_signal требует больше чем одну команду; и возможно сигнал случиться в середине. Но это не вызывает никакой проблемы. Если сигнал случается достаточно рано чтобы увидеть значение до приращения или уменьшения, то это эквивалентно сигналу который, пришел перед началом приращения или уменьшения, что является случаем который работает правильно.
Абсолютно необходимо увеличить defer_signal перед тестированием signal_pending, потому что это позволяет избежать тонкой ошибки. Если бы мы делали это в другом порядке, примерно так,
if (defer_signal == 1 && signal_pending != 0)
raise (signal_pending);
defer_signal--;
Ошибки подобно этим, называются ошибками синхронизации. Они особенно опасны, потому что они случаются редко и их почти невозможны воспроизвести. Вы не сможете найти их отладчиком, как Вы нашли бы воспроизводимую ошибку. Так что надо быть особенно осторожным, чтобы избежать их.
Если ваша программа управляется внешними событиями, или использует сигналы для синхронизации, то она должена возможно ждать, пока сигнал не прибудет.
Простой способ ждать прибытия сигнала - вызвать pause.
int pause () (функция)
Если сигнал выполняет функцию обработчика, то pause возвращается. Это рассматривается как неудача (так как "успешное" поведение должно было бы приостановить программу навсегда), так что возвращаемое значение -1. Даже если Вы определяете, что другие примитивы должны продолжиться, когда обработчик системы возвращается (см. Раздел 21.5 [Прерванные Примитивы]), это не имеет никакого эффекта на pause; она всегда терпит неудачу, когда сигнал обработан.
Следующие errno условия ошибки определены для этой функции:
функция была прервана сигналом.
Функция pause объявлена в " unistd.h ".
Простота pause может скрывать серьезные ошибки синхронизации, которые могут привести программу к зависанию.
Безопасно использовать pause, если реальная работа вашей программы выполняется обработчиками сигнала непосредственно, а программа не делает ничего кроме обращения к pause. Каждый сигнал будет заставлять обработчик делать следующий пакет работы, которая должна быть выполнена, и возвращаться, так чтобы цикл программы мог вызывать pause снова.
Вы не можете безопасно использовать pause, чтобы ждать, пока не прибудет еще один сигнал, и тогда продолжить реальную работу.
Даже если Вы принимаете меры, чтобы обработчик сигнала сотрудничал, устанавливая флаг, Вы все еще не можете использовать pause надежно. Вот пример такой проблемы:
if (!usr_interrupt)
pause ();
/* работа, после прибытия сигнала. * /
. . .
Вы можете изменять верхнее ограничение ожидания, используя sleep в цикле, вместо того чтобы использовать pause. (См. Раздел 17.4 [Бездействие].) Вот, на что это походит:
while (!usr_interrupt)
sleep (1);
/* работа, после прибытия сигнала. */
. . .
Чистый и надежный способ ждать сигнал состоит в том, чтобы блокировать его и тогда использовать sigsuspend.
Используя sigsuspend в цикле, Вы можете ждать некоторые виды сигналов, разрешая другим видам сигналов обрабатываться их обработчиками.
int sigsuspend (const sigset_t *set) (функция)
Если процесс пробужден сигналом, который вызывает функцию обработчика, и функция обработчика возвращается, то sigsuspend также возвращается.
Маска остается set только, пока sigsuspend ждет. Функция sigsuspend всегда восстанавливает предыдущую маску сигналов, когда она возвращается.
Возвращаемое значение и условия ошибки - такие же как для pause.
С sigsuspend, Вы можете заменять pause или цикл sleep в предыдущем разделе кое-чем полностью надежным:
sigset_t mask, oldmask;
. . .
sigemptyset (&mask);
sigaddset (&mask, SIGUSR1);
. . .
/ * Ждем получения сигнала. * /
sigprocmask (SIG_BLOCK, &mask, &oldmask);
while (!usr_interrupt)
sigsuspend (&oldmask);
sigprocmask (SIG_UNBLOCK, &mask, NULL);
Этот раздел описывает альтернативные функции обработки сигнала, происходящие от UNIX BSD. Эти средства были современными, в их время; сегодня, они обычно устаревшие, и обеспечены в основном для совместимости с UNIX BSD.
Они обеспечивают одну возможность, которая не доступна через функции POSIX: Вы можете определять отдельный стек для использования в некоторых обработчиках сигнала. Использование стека сигнала единственый способ, которым Вы можете обрабатывать сигнал, вызванный переполнением стека.
Имеются много подобий между BSD и POSIX средствми обрабатывающими сигналы, потому что средства POSIX были вдохновлены средствами BSD. Кроме наличия различных имен для всех функций, чтобы избежать конфликтов, есть несколько основных различий:
struct sigvec (тип данных)
sighandler_t sv_handler
int sv_mask
int sv_flags
int SV_ONSTACK
int SV_INTERRUPT (макрос)
int SV_RESETHAND (макрос)
int sigvec (int signum, const struct sigvec *action,struct sigvec *old_action)
int siginterrupt (int signum, int failflag) (функция)
int sigmask (int signum) (макрос)
(sigmask (SIGTSTP) | sigmask (SIGSTOP)
| sigmask (SIGTTIN) | sigmask (SIGTTOU))
int sigblock (int mask) (функция)
int sigsetmask (int mask) (функция)
int sigpause (int mask) (функция)
Стек сигнала - специальная область памяти, которую нужно исполь зовать как стек в течение выполнения обработчиков сигнала. Он должен быть довольно большим, чтобы избежать переполнения; макрокоманда SIGS TKSZ определяет канонический размер для стеков сигналов. Вы можете ис пользовать malloc, чтобы зарезервировать пространство для стека. Вызо вите sigaltstack или sigstack, чтобы система использовала это прост ранство для стека сигнала.
Вам не нужно писать обработчик сигнала по-другому чтобы использо вать стек сигнала. Переключение одного стека на другой происходит ав томатически. Однако, некоторые отладчики на некоторых машинах могут запутаться, если Вы исследуете след стека, в то время как обработчик, который использует стек сигнала, выполняется.
Имеются два интерфейса для сообщения системе использовать отдель ный стек сигнала. Sigstack - более старый интерфейс, который исходит из 4.2 BSD. Sigaltstack - более новый интерфейс, и исходит из 4.4 BSD. Интерфейс sigaltstack имеет преимущество - не требуется, чтобы ваша программа знала в каком направлении растет стек, что зависит от специ фической машины и операционной системы.
struct sigaltstack (тип данных)
void *ss_sp
size_t ss_size
SIGSTKSZ
MINSIGSTKSZ
Для большинства случаев SIGSTKSZ для ss_size достаточен. Но Вы можете захотеть использовать различный размер. В этом случае, Вы долж ны зарезервировать MINSIGSTKSZ дополнительных байт для стека сигнала и увеличивать ss_size.
int ss_flags
SA_DISABLE
SA_ONSTACK
int sigaltstack (const struct sigaltstack *stack, struct sigaltstack *oldstack) (функция)
Если oldstack - не пустой указатель, информация относительно в настоящее время установленного стека сигнала будет возвращена в распо ложение, на которое он указывает. Если stack - не пустой указатель, то он будет установлен как новый стек для использования обработчиками сигнала.
Возвращаемое значение - 0 при успехе и -1 при отказе. Если si galtstack сбоит, она устанавливает errno как одно из этих значений:
Вы пробовали отключать стек, который был фактически использован в настоящее время.
Размер альтернативного стека был слишком мал. Он должен быть большее чем MINSIGSTKSZ.
struct sigstack (тип данных)
void *ss_sp
int ss_onstack
int sigstack (const struct sigstack *stack, struct sigstack *oldstack) (функция)
Когда сигнал получен процессом, и стек сигнала используется, система переключается на в настоящее время установленный стек сигнала, в то время как выполняется обработчик для этого сигнала.
Если oldstack - не, пустой указатель, информация относительно в настоящее время установленного стека сигнала будет возвращена в расположение, на которое он указывает. Если stack - не пустой указатель, то он будет установлен как новый стек для использования обработчиками сигнала.
Возвращаемое значение - 0 при успехе и -1 при отказе.
Процессы - примитивные модули для распределения ресурсов системы. Каждый процесс имеет собственное адресное пространство. Процесс выполняет программу; Вы можете иметь многократные процессы, выполняющие ту же самую программу, но каждый процесс имеет собственную копию программы внутри собственного адресного пространства и выполняет ее независимо от других копий.
Эта глава объясняет, что ваша программа должна делать, чтобы обработать запуск процесса, завершить процесс, и получить информацию (аргументы и среду) из родительского процесса.
Система начинает программу C, вызывая функцию main. Вы должны написать функцию, именованную main, иначе Вы не будете способны линковать вашу программу без ошибок.
Вы можете определять main без аргументов, или брать два аргумента, которые представляют аргументы командной строки программы, примерно так:
int main (int argc, char *argv[])
Значение argc аргумента - число аргументов командной строки. Аргумент argv - вектор строк; элементы - индивидуальные строки аргументов командной строки. Имя файла выполняемой программы также включено в вектор как первый элемент; значение argc учитывает этот элемент. Пустой указатель всегда следует за последним элементом: argv [argc] - это пустой указатель.
Для команды " cat foo bar ", argc - 3, и argv имеет три элемента, " cat ", " foo " и " bar ".
Если синтаксис для аргументов командной строки вашей программы является достаточно простым, Вы может просто выбирать аргументы из argv вручную. Но если ваша программа берет фиксированное число аргументов, или все аргументы интерпретируются одинаковым образом (как имена файлов, например), Вам лучше использовать getopt, чтобы делать синтаксический анализ.
POSIX рекомендует эти соглашения для аргументов командной строки. Getopt (см. Раздел 22.1.2 [Опции Синтаксического анализа]) облегчит их реализацию.
Пример длинной опции " --name=value ". Этот синтаксис дает возможность длинной опции принять аргумент, который является самостоятельно необязательным.
В конечном счете, система GNU будет обеспечивать длинные имена опций в оболочке.
Имеются подробности относительно того, как вызвать getopt функцию. Чтобы использовать это средство, ваша программа должна включить заглавный файл " unistd.h ".
int opterr (переменная)
int optopt (переменная)
int optind (переменная)
char * optarg (переменная)
int getopt (int argc, char **argv, const char *options) (функция)
Аргумент-опция - строка, которая определяет символы опции, которые являются допустимыми для этой программы. Символ опции в этой строке может сопровождаться двоеточием (": ") чтобы указать, что она берет требуемый аргумент.
Если строка аргумента-опции начинается с дефиса (" - "), она обрабатывается особенно. Это разрешает аргументам-не-опциям, возвращаться, как будто они были связаны с последним символом опции.
Getopt функция возвращает символ опции для следующей опции командной строки. Когда нет больше аргументов-опций, она возвращает -1. Может все еще иметься большое количество аргументов-не-опций; Вы должны сравнить внешнюю переменную optind c параметром argc, чтобы проверить это.
Если опция имеет аргумент, getopt возвращает аргумент, сохраняя его в переменной optarg. Вы обычно не должны копировать optarg строку, так как это - указатель в первоначальный массив argv, а не в статическую область, которая могла бы быть перезаписана.
Если getopt находит символ опции в argv, который не был включен в опции, или отсутствующий аргумент некоторой опции, она возвращает "? ", устанавливает внешнюю переменную optopt как фактический символ опции. Если первый символ опции - двоеточие (":"), то getopt возвращает ":" вместо "? " Чтобы указать отсутствующий аргумент опции. Кроме того, если внешняя переменная opterr отлична от нуля (который является значением по умолчанию), getopt печатает сообщение об ошибках.
Вот пример, показывающий, как getopt обычно используется:
#include <unistd.h>
#include <stdio.h>
int
main (int argc, char **argv)
{
int aflag = 0;
int bflag = 0;
char *cvalue = NULL;
int index;
int c;
opterr = 0;
while ((c = getopt (argc, argv, "abc:")) != -1)
switch (c)
{
case 'a':
aflag = 1;
break;
case 'b':
bflag = 1;
break;
case 'c':
cvalue = optarg;
break;
case '?':
if (isprint (optopt))
fprintf (stderr, "Unknown option
`-%c'.\n", optopt);
else
fprintf (stderr, "Unknown option
character `\\x%x'.\n", optopt);
return 1;
default:
abort ();
}
printf ("aflag = %d, bflag = %d, cvalue = %s\n",
aflag, bflag, cvalue);
for (index = optind; index < argc; index++)
printf ("Non-option argument %s\n",
argv[index]);
return 0;
}
% testopt
aflag = 0, bflag = 0, cvalue = (null)
% testopt -a -b
aflag = 1, bflag = 1, cvalue = (null)
% testopt -ab
aflag = 1, bflag = 1, cvalue = (null)
% testopt -c foo
aflag = 0, bflag = 0, cvalue = foo
% testopt -cfoo
aflag = 0, bflag = 0, cvalue = foo
% testopt arg1
aflag = 0, bflag = 0, cvalue = (null)
Non-option argument arg1
% testopt -a arg1
aflag = 1, bflag = 0, cvalue = (null)
Non-option argument arg1
% testopt -c foo arg1
aflag = 0, bflag = 0, cvalue = foo
Non-option argument arg1
% testopt -a -- -b
aflag = 1, bflag = 0, cvalue = (null)
Non-option argument -b
% testopt -a
aflag = 1, bflag = 0, cvalue = (null)
Non-option argument
Чтобы воспринимать GNU стиль длинных опций также как одиночно символьные опции, используйте getopt_long вместо getopt. Вы должны заставить каждую программу принимать длинные опции, если она использует опции, это занимает немного ресурсов, и помогает новичкам помнить, как использовать программу.
struct option (тип данных)
Завершите массив элементом, содержащим все нули.
Структура option имеет поля:
const char *name
int has_arg
int *flag
int val
Если flag - пустой указатель, то val - значение, которое идентифицирует эту опцию. Часто эти значения выбраны, чтобы однозначно идентифицировать специфические длинные опции.
Если flag - не пустой указатель, это должен быть адрес int переменной, которая является флагом для этой опции. Значение в val - значение, которое нужно сохранить во флаге, чтобы указать, что опция была замечена.
int getopt_long (int argc, char **argv, const char *shortopts, struct option *longopts, int *indexptr) (функция)
Когда getopt_long сталкивается с короткой опцией, она делает ту же самую вещь, что и getopt: она возвращает символьный код для опции, и сохраняет аргумент этой опции (если он имеется) в optarg.
Когда getopt_long сталкивается с длинной опцией, она действует, основываясь на flag и val полях определения этой опции.
Если flag - пустой указатель, то getopt_long возвращает содержимое val, чтобы указать какую опцию она нашла. Вы должны указывать различные значения в val поле для опций с различными значениями, так что Вы можете декодировать эти значения после того, как getopt_long возвращается. Если длинная опция эквивалентна короткой опции, Вы может использовать код символа короткой опции в val.
Если flag - не пустой указатель, значит эта опция должна только установить флаг в программе. Флаг - переменная типа int, что Вы и определяете. Поместите адрес флага в поле flag. Поместите в val поле значение, которое Вы хотели бы, чтобы эта опция сохранила во флаге. В этом случае, getopt_long возвращает 0.
Для любой длинной опции, getopt_long сообщает Вам индекс в массиве longopts определения опций, сохраняя его в *indexptr. Вы можете получить имя опции через longopts [*indexptr].name . Так что Вы можете различать длинные опции или значениями в их val полях или их индексами.
Когда длинная опция имеет аргумент, getopt_long помещает значение аргумента в переменную optarg перед возвращением. Когда опция не имеет никакого аргумента, значение в optarg - пустой указатель.
Когда getopt_long не имеет больше опций для обработки, она возвращает -1, и оставляет в переменной optind индекс следующего остающегося аргумента в argv.
#include <stdio.h>
static int verbose_flag;
int
main (argc, argv)
int argc;
char **argv;
{
int c;
while (1)
{
static struct option long_options[] = {
{"verbose", 0, &verbose_flag, 1},
{"brief", 0, &verbose_flag, 0},
{"add", 1, 0, 0},
{"append", 0, 0, 0},
{"delete", 1, 0, 0},
{"create", 0, 0, 0},
{"file", 1, 0, 0},
{0, 0, 0, 0}
};
int option_index = 0;
c = getopt_long (argc, argv, "abc:d:",
long_options, &option_index);
if (c == -1)
break;
switch (c)
{
case 0:
if (long_options[option_index].flag
!= 0)
break;
printf ("option %s",
long_options[option_index].name);
if (optarg)
printf (" with arg %s", optarg);
printf ("\n");
break;
case 'a':
puts ("option -a\n");
break;
case 'b':
puts ("option -b\n");
break;
case 'c':
printf ("option -c with value
`%s'\n", optarg);
break;
case 'd':
printf ("option -d with value
`%s'\n", optarg);
break;
case '?':
/* getopt_long already printed an error message. */
break;
default:
abort ();
}
}
if (verbose_flag)
puts ("verbose flag is set");
/* Печатаем любые остающиеся аргументы командной строки
(не опции). */
if (optind < argc)
{
printf ("non-option ARGV-elements: ");
while (optind < argc)
printf ("%s ", argv[optind++]);
putchar ('\n');
}
exit (0);
}
Когда программа выполняется, она получает информацию относительно контекста, в котором она вызывалась двумя способами. Первый механизм использует argv и argc аргументы функции main, и обсужден в Разделе 22.1 [Аргументы Программы]. Второй механизм использует переменные среды и обсужден в этом разделе.
Механизм argv обычно используется, чтобы передать аргументы командной строки, специфические для специфической вызываемой программы. Среда, с другой стороны, следит за информацией, которая разделена многими программами, и к ней менее часто обращаются.
Переменные среды, обсужденные в этом разделе - те же самые переменные среды, что Вы устанавливаете используя присванивание и команду export в оболочке. Программы, выполненные из оболочки наследуют все переменные среды из оболочки.
Стандартные переменные среды используются для уточнения инфрмации относительно исходного каталога пользователя, типа терминала, текущего стандарта, и так далее; Вы можете определять дополнительные переменные для других целей. Набор всех переменных среды, которые имеют значения, общеизвестен как среда.
Имена переменных среды чувствительны к регистру и не должны содержать символ "=".
Определенные системой переменные среды неизменны относительно верхнего регистра.
Значения переменных среды могут быть чем угодно, что может представляться как строка. Значение не должно содержать внедренный пустой символ, так как им принято завершать строку.
К значению переменной среды можно обращаться getenv функцией. Это объявлено в заглавном файле " stdlib.h ".
char * getenv (const char *name) (функция)
int putenv (const char *string) (функция)
Библиотека GNU обеспечивает эту функцию для совместимости с SVID; она не может быть доступна в других системах.
Вы можете иметь дело непосредственно с основным представлением объектов среды, чтобы добавить большое количество переменных к среде (например, связываться с другой программой, которую Вы собираетесь выполнять; см. Раздел 23.5 [Выполнение Файла]).
char ** environ (переменная)
Эта переменная объявлена в заглавном файле " unistd.h ".
Если Вы хотите только получить значение переменной среды, использует getenv.
Эти переменные среды имеют стандартные значения. Это не означает, что они всегда представляются в среде; но если эти переменные присутствуют, они имеют эти значения, и Вы не должны пробовать использовать эти имена переменных среды для некоторой другой цели.
HOME
Пользователь может устанавливать HOME как любое значение. Если, Вы должны получить соответствующий исходный каталог для специфического пользователя, Вы не должен использовать HOME; взамен, найдите имя пользователя в базе данных пользователей (см. Раздел 25.12 [База данных Пользователей]).
LOGNAME
Для большинства целей, лучше использовать LOGNAME, потому что она позволяет пользователю определять значение.
PATH
Execlp и execvp функции (см. Раздел 23.5 [Выполнение Файла]) используют эту переменную среды, как и многие оболочки и другие утилиты, которые выполнены в терминах этих функций.
Синтаксис пути - последовательность имен каталогов, отделяемых двоеточиями. Пустая строка вместо имени каталога замещает текущий каталог (см. Раздел 9.1 [Рабочий каталог]).
Типичное значение для этой переменной среды могло бы быть: :/bin:/etc:/usr/bin:/usr/new/X11:/usr/new:/usr/local/bin
Это означает что, если пользователь пробует выполнять программу, именованную foo, система будет искать файлы, именованные " foo ", " /bin/foo ", " /etc/foo ", и так далее. Первый из этих файлов, который существует - будет выполнен.
TERM
TZ
LANG
LC_COLLATE
LC_CTYPE
LC_MONETARY
LC_NUMERIC
LC_TIME
_POSIX_OPTION_ORDER
Обычный способ завершения программы - просто возврат функции main. Значение состояния выхода, возвращенное из функции main используется, чтобы сообщить информацию обратно родительскому процессу или оболочке.
Программа может также завершаться вызывая функцию exit.
Кроме того, программы могут быть завершены сигналами; это обсуждено более подробно в Главе 21 [Обработка Сигналов]. Функция abort вызывает сигнал, который уничтожает программу.
Процесс завершается обычно, когда программа вызывает exit. Возвращение из main эквивалентно вызову exit, и значение, которое main возвращает, используется как аргумент exit.
void exit (int status) (функция)
Нормальное окончание вызывает следующие действия:
Когда программа выходит, она может возвращать родительскому процессу малое количество информации относительно причины окончания, используя состояние exit. Это - значение между 0 и 255, которое выходящий процесс передает как аргумент exit.
Обычно Вы должны использовать состояние exit, чтобы сообщить очень широкую информацию относительно успеха или отказа. Вы не можете обеспечивать множество подробностей относительно причин для отказа, да и большинство родительских процессов не требуют много подробностей.
Имеются соглашения для того, что некоторые программы должны возвратить. Наиболее общее соглашение - просто 0 для успеха и 1 для отказа. Программы, которые выполняют сравнение, используют другое соглашение: они используют состояние, 1, чтобы указать несоответствие, и состояние 2, чтобы указать неспособность сравнить. Ваша программа должна следовать за существующим соглашением, если существующее соглашение имеет смысл для нее.
Общее соглашение резервирует значения 128 состояний и более для специальных целей. В частности значение 128 используется, чтобы указать отказ выполнить другую программу в подпроцессе. Это соглашение не удовлетворяет унивверсальным условиям, но неплохо следовать за ним в ваших программах.
Предупреждение: Не пробуйте использовать число ошибок как состояние exit. Это фактически не очень полезно; родительский процесс вообще не должен заботиться, сколько ошибок произошло. К тому же значение состояния усекается до восьми бит. Таким образом, если программа пробовала передать 256, родитель получит 0 шибок т.е. успех.
По той же самой причине не работает использование значения errno как состояния exit.
Примечание Переносимости: Некоторые не-posix системы используют различные соглашения для значений состояния exit. Для большей переносимости, Вы можете использовать макрокоманды EXIT_SUCCESS и EXIT_FAILURE для стандартного значения состояния успеха и отказа, соответственно. Они объявлены в файле " stdlib.h ".
int EXIT_SUCCESS (макрос)
На системах POSIX, значение этой макрокоманды - 0. В других системах, значение может быть другим (возможно не-константа) целочисленным выражением.
int EXIT_FAILURE (макрос)
На системах POSIX, значение этой макрокоманды 1. На других системах, значение может быть другим.
Ваша программа может выполнить собственные функции очистки при нормальное окончании. Ненадежно вызывать функции очистки явно перед выходом. Намного лучше делать очистку невидимой для приложения, устанавливая функцию очистки используя atexit или on_exit.
int atexit (void (*function) (void)) (функция)
Возвращаемое значение из atexit - нуль при успехе и отличное от нуля, если функция не может быть зарегистрирована.
int on_exit (void (*function)(int status, void *arg), void *arg)
Эта функция включена в библиотеку GNU C только для совместимости с SunOS, и может не обеспечиваться другими реализациями.
Имеется тривиальная программа, которая иллюстрирует использование exit и atexit:
#include <stdio.h>
#include <stdlib.h>
void
bye (void)
{
puts ("Goodbye, cruel world....");
}
int
main (void)
{
atexit (bye);
exit (EXIT_SUCCESS);
}
Вы можете прервать вашу программу, используя функцию abort. Прототип для этой функции находится в " stdlib.h ".
void abort (void) (функция)
Эта функция фактически завершает процесс, вызывая сигнал SIGABRT, и ваша программа может включать обработчик, чтобы прервать этот сигнал; см. Главу 21 [Обработка Сигнала].
Функция _exit - примитив, используемый для окончания процесса exit. Она объявлена в заглавном файле " unistd.h ".
void _exit (int status) (функция)
Когда процесс завершается по любой причине либо явным запросом окончания, либо окончанием в результате сигнала, производятся следующие действия:
Процессы - примитивные модули для резервирования ресурсов системы. Каждый процесс имеет собственное адресное пространство. Процесс выполняет программу; Вы можете иметь многократные процессы, выполняющие ту же самую программу, но каждый процесс имеет собственную копию программы внутри собственного адресного пространства и выполняет это независимо от других копий.
Процессы организованы иерархически. Каждый процесс имеет родительский процесс. Процессы, созданные данным родителем называются дочерними процессами. Дочерний наследует многие из атрибутов родительского процесса.
Эта глава описывает, как программа может создавать, завершать, и управлять дочерними процессами. Фактически, имеются три различных операции: создание нового дочернего процесса, назначение новому процессу выполнить программу, и координирование завершения дочернего процесса.
Функция системы обеспечивает простой механизм для выполнения другой программы; он делает все три шага автоматически. Если Вы нуждаетесь в большом количестве контроля, Вы можете использовать примитивные функции, чтобы делать каждый шаг индивидуально.
Простой способ выполнять другую программу состоит в том, чтобы использовать функцию system. Эта функция делает всю работу выполнения подпрограммы, но она не дает Вам контроля над подробностями: Вы должны ждать, пока подпрограмма не завершится прежде, чем Вы сможете делать что-нибудь еще.
int system (const char *command) (функция)
Функция system объявлена в заглавном файле " stdlib.h ".
Примечание Переносимости: Некоторые реализации C могут не иметь понятие командного процессора, который может выполнять другие программы. Вы можете определить, существует ли командный процессор, выполняя system (NULL); если возвращаемое значение отлично от нуля, командный процессор доступен.
Popen и pclose функции (см. Раздел 10.2 [Трубопровод на Подпроцесса]) близко связаны функцией system. Они позволяют родительскому процессу связываться со стандартным вводом и выводом выполняемой команды.
Этот раздел дает краткий обзор действий и шагов по созданию процесса и выполнения им другой программы.
Каждый процесс именован ID процесса. Уникальный ID процесса дан каждому процессу при создании.
Процессы создаются системным вызовом fork (так что операция создания нового процесса иногда вызывает раздваивание процесса). Дочерний процесс, созданный fork - точный аналог первоначального родительского процесса, за исключением того, что он имеет собственный ID.
Если Вы хотите, чтобы ваша программа ждала завершения дочернего процесса, Вы должен делать это явно после операции fork, вызовом wait или waitpid (см. Раздел 23.6 [Завершение Процесса]). Эти функции дают Вам ограниченную информацию относительно того, почему завершился дочерний прцесс - например, код состояния exit.
Раздвоенный дочерний процесс продолжает выполнять ту же самую программу как родительский процесс, в точке возвращения fork. Вы можете использовать возвращаемое значение от fork, чтобы отличить, выполняется ли программа в родительском процессе или в дочернем.
Наличие нескольких процессов выполняющх ту же самую программу не очень полезно. Но дочерний может выполнять другую программу, используя одну из запускающих функций; см. Раздел 23.5 [Выполнение Файла]. Программа, которую процесс выполняет, называется образом процесса. Начало выполнения новой программы заставляет процесс забыть все относительно предыдущего образа процесса; когда программа выходит, процесс тоже выходит, вместо того, чтобы возвратиться к предыдущему образу процесса.
Pid_t тип данных для ID процесса. Вы можете получить ID процесса, вызывая getpid. Функция getppid возвращает ID родителя текущего процесса (это также известно как ID родительского процесса). Ваша программа должна включить заглавные файлы " unistd.h " и " sys/types.h " чтобы использовать эти функции.
pid_t (тип данных)
pid_t getpid (void) (функция)
pid_t getppid (void) (функция)
Функция fork - примитив для создания процесса. Она объявлена в заглавном файле " unistd.h ".
pid_t fork (void) (функция)
Если операция является успешной, то и родительский и дочерний процессы видят что fork возвращается, но с различными значениями: она возвращает значение 0 в дочернем процессе и ID порожденного процесса (ребенка) в родительском процессе.
Если создание процесса потерпело неудачу, fork возвращает значение -1 в родительском процессе. Следующие errno условия ошибки определены для fork:
не имеется достаточных ресурсов системы чтобы создать другой процесс, или пользователь уже имеет слишком много процессов.
процесс требует большего количества места чем система могла обеспечить.
pid_t vfork (void) (функция)
В то время как fork делает полную копию адресного пространства вызывающего процесса и позволяет, и родителю и дочернему выполняться независимо, vfork не делает эту копию.
Взамен, дочерний процесс, созданный с vfork совместно использует адресное пространство родителя, пока он не вызывает одну из функций exec. Тем временем, родительский процесс приостанавливает свое выполнение.
Вы должны быть очень осторожны, чтобы не позволить дочернему процессу, созданному с vfork изменять любые глобальные данные или даже локальные переменные, общедоступнные с родителем. Кроме того, дочерний процесс не может возвращаться из (или делать длинный переход) функции, которая вызвала vfork! Это спутало бы информацию управления родительского процесса. Если Вы сомневаетесь, используйте fork.
Некоторые операционные системы не выполняют vfork. Библиотека GNU C разрешает Вам использовать vfork на всех системах, но фактически выполняет fork, если vfork не доступна. Если Вы соблюдаете соответствующие предосторожности при использовании vfork, ваша программа будет работать, даже если система использует fork взамен.
Этот раздел описывает совокупность exec функций, для выполнения файла как образа процесса. Вы можете использовать эти функции, чтобы заставить дочерний процесс выполнить новую программу после того, как он был раздвоен.
Эти функции отличаются тем, как Вы определяете аргументы, но они все делают ту же самую вещь. Они объявлены в заглавном файле " unistd.h ".
int execv (const char *filename, char *const argv[]) (функция)
Аргумент argv - массив строк с нулевым символом в конце, который используется, чтобы обеспечить значение для аргумента argv функции main программы, которая будет выполнена. Последний элемент этого массива должен быть пустой указатель. Обычно, первый элемент этого массива - имя файла программы. См. Раздел 22.1 [Аргументы Программы] , для подробностей относительно того, как программы могут обращаться к этим аргументам.
Среда для нового образа процесса берется из переменной environ текущего образа процесса; см. Раздел 22.2 [Переменные среды], для уточнения инфрмации относительно сред.
int execl (const char *filename, const char *arg0, . . .) (функция)
int execve (const char *filename, char *const argv[], char *const env[])
int execle (const char *filename, const char *arg0, char *const env[], . . .)
int execvp (const char *filename, char *const argv[]) (функция)
Эта функция полезна для выполняющихся утилит системы, потому что она ищет их в местах, которые пользователь выбрал. Оболочки используют ее, чтобы выполнить команды написанные пользователем.
int execlp (const char *filename, const char *arg0, . . .) (функция)
Размер списка параметров и списка среды, вместе не должен быть больше чем ARG_MAX байт. См. Раздел 27.1 [Общие Ограничения]. В системе GNU, размер (который сравнивается c ARG_MAX) включает, для каждой строки, число символов в строке, плюс размер char*, плюс один, округленный вверх после умножения на размер char*. Другие системы могут иметь несколько отличные правила для подсчета.
Эти функции обычно не возвращаются, так как выполнение новой программы заставляет завершиться программу выполнения в настоящее время. Значение -1 возвращено в случае отказа. В дополнение к обычным синтаксическим ошибкам имени файла (см. Раздел 6.2.3 [Ошибки Имени файла]), следующие errno условия ошибки определены для этих функций: E2BIG объединенный размер списка параметров новой программы и списка среды больше чем ARG_MAX байт. Система GNU не имеет никакого специфического ограничения размера списка параметров, так что этот код ошибки не может получиться, но Вы можете получать ENOMEM взамен, если аргументы слишком большие для доступной памяти.
заданный файл не может быть выполнен, потому что он не находится в правильном формате.
Выполнение заданного файла требует большего количества памяти чем было доступно.
Выполнение нового образа процесса полностью не изменяет содержимое памяти, копируются только аргументы и строки среды. Но много других атрибутов процесса неизменяемы:
Описатели Файла, открытые в существующем образе процесса остаются открытыми в новом образе процесса, если они не имеют FD_CLOEXEC флага. Файлы, которые остаются открытыми, наследуют все атрибуты описания открытого файла из существующего образа процесса, включая блокировки файла. Описатели Файла обсуждены в Главе 8 [Ввод - вывод низкого уровня].
Новый образ процесса не имеет никаких потоков за исключением тех, что он создает заново.
Каждый из потоков в предыдущем образе процесса имеет описатель внутри него, и эти описатели остаются после exec (если они не имеют FD_CLOEXEC). Новый образ процесса может повторно соединять их с новыми потоками, используя fdopen (см. Раздел 8.4 [Описатели и Потоки]).
Функции, описанные в этом разделе используются, чтобы ждать завершения или останова дочернего процесса и определять его состояние. Эти функции объявлены в заглавном файле " sys/wait.h ".
pid_t waitpid (pid_t pid, int *status_ptr, int options) (функция)
Другие значения для pid аргумента имеют специальные интерпретации. Значение -1 или WAIT_ANY информация состояния для любого дочернего процесса; значение 0 или WAIT_MYPGRP запрашивает информацию для любого дочернего процесса в той же самой группе процесса как вызывающий процесс; и любое другое отрицательное значение - pgid запрашивает информацию для любого дочернего процесса, чей ID группы - pgid.
Если информация состояния дочернего процесса доступна немедленно, эта функция возвращается немедленно без ожидания. Если доступна информация состояния больше чем одного готового продолжиться дочернего процесса, один из них будет выбран беспорядочно, и его состояние возвращено немедленно.
Чтобы получить состояние других готовых продолжиться дочерних процессов, Вы должны вызвать waitpid снова.
Аргумент options - битовая маска. Значение должно быть поразрядным ИЛИ (то есть `|') нуля или большого количества WNOHANG и WUNTRACED флагов. Вы можете использовать WNOHANG флаг, чтобы указать, что родительский процесс не должен ждать; и WUNTRACED флаг, чтобы запросить информацию состояния остановленных процессов также как процессов, которые завершились.
Информация состояния дочернего процесса сохранена в объекте, на который указывает status_ptr, если status_ptr не пустой указатель.
Возвращаемое значение - обычно ID дочернего процесса, о чьем состояние сообщено. Если WNOHANG опция была определена и никакой дочерний процесс, не ждет, чтобы быть отмеченным, то значение - нуль. Значение -1 возвращено в случае ошибки. Следующие errno ошибки определены для этой функции:
Функция была прервана получением сигнала. См. Раздел 21.5 [Прерванные Примитивы].
Не имеется никаких дочерних процессов, или заданный pid не дочерний для вызывающего процесса.
Недопустимое значение аргумента options.
WAIT_ANY
WAIT_MYPGRP
Эти символические константы определены как флаги для аргумента options функции waitpid.
Вы можете сделать OR флагов вместе, чтобы получить значение, и использовать его как аргумент.
WNOHANG
WUNTRACED
pid_t wait (int *status_ptr) (функция)
wait (&status)
waitpid (-1, &status, 0)
void
sigchld_handler (int signum)
{
int pid;
int status;
while (1)
{
pid = waitpid (WAIT_ANY, &status,
WNOHANG);
if (pid < 0)
{
perror ("waitpid");
break;
}
if (pid == 0)
break;
notice_termination (pid, status);
}
}
Если значение состояния выхода (см. Раздел 22.3 [Завершение Программы]) дочернего процесса - нуль, то значение состояния, сообщенное waitpid или wait - также нуль. Вы можете проверять другие виды информации, закодированные в возвращенном значении состояния, используя следующие макрокоманды. Эти макрокоманды определены в заглавном файле " sys/wait.h ".
int WIFEXITED (int status)
int WEXITSTATUS (int status)
int WIFSIGNALED (int status)
int WTERMSIG (int status)
int WCOREDUMP (int status)
int WIFSTOPPED (int status)
int WSTOPSIG (int status)
Библиотека GNU также обеспечивает эти средства для совместимости с UNIX BSD. BSD использует тип данных union, чтобы представить значения состояния, а не int. Два представления фактически взаимозаменяемы; они описывают те же самые битовые шаблоны. Библиотека GNU C определяет макрокоманды типа WEXITSTATUS так, чтобы они работали на любом виде объекта, и функция wait определена, чтобы принять любой тип указателя как аргумент status_ptr.
Эти функции объявлены в " sys/wait.h ".
union wait (тип данных)
int w_termsig
int w_coredump
int w_retcode
int w_stopsig
Вместо того, чтобы обращаться к этим элементам непосредственно, Вы должны использовать эквивалентные макрокоманды.
pid_t wait3 (union wait *status_ptr, int options, struct rusage *usage)
Если usage - не пустой символ, wait3 сохраняет тип использования для дочернего процесса в *rusage (но только, если дочерний завершился, а не остановился). См. Раздел 17.5 [Использование Ресурсов].
pid_t wait4 (pid_t pid, union wait *status_ptr, int options, struct rusage *usage)
Если usage - не пустой символ, wait4 сохраняет тип использования для дочернего процесса в *rusage (но только, если дочерний завершился, а не остановился). См. Раздел 17.5 [Использование Ресурсов].
Вот пример программы, показывающий, как Вы могли бы написать функцию, подобную встроенной системе. Она выполняет аргумент command, используя " sh -c command ".
#include <stddef.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#define SHELL "/bin/sh"
int
my_system (const char *command)
{
int status;
pid_t pid;
pid = fork ();
if (pid == 0)
{
execl (SHELL, SHELL, "-c", command,
NULL);
_exit (EXIT_FAILURE);
}
else if (pid < 0)
status = -1;
else
if (waitpid (pid, &status, 0) != pid)
status = -1;
return status;
}
Не забудьте, что первый аргумент argv, представляет имя выполняемой программы. Именно поэтому, в обращении к execl, SHELL обеспечена один раз, чтобы назвать выполняемую программу, и второй раз, чтобы обеспечить значение для argv [0].
Вызов execl в дочернем процессе не возвращается, если он успешен. Если он терпит неудачу, Вы должен делать кое-что, чтобы заставить дочерний процесс завершиться. Правильное поведение для дочернего процесса - сообщить отказ родительскому процессу.
Вызовите _exit, чтобы выполнить это. Причина для использования _exit вместо exit состоит в том, чтобы избежать flush полностью буферизированных потоков типа stdout. Буфера этих потоков возможно содержат данные, которые были скопированы из родительского процесса функцией fork, эти данные будут выводиться в конечном счете родительским процессом. Вызов exit в дочернем вывел бы данные дважды. См. Раздел 22.3.5 [Внутренняя организация Окончания].
Управление заданиями относится к протоколу для разрешения пользователю двигаться между многими группами процессов (или работ) внутри одиночного сеанса входа в систему. Средства управления заданиями установлены так, чтобы соответствующее поведение для большинства программ устанавливалось автоматически и они не должны делать что-нибудь специальное относительно управления заданиями. Так что Вы можете возможно игнорировать материал этой главы, если Вы не пишите программу входа в систему или оболочку.
Вы должны быть знакомы с понятиями создания процесса (см. Раздел 23.2 [Понятия Создания Процесса]) и обработки сигналов (см. Главу 21 [Обработка Сигналов]) чтобы понять материал этой главы.
Фундаментальная цель интерактивной оболочки читать команды из терминала пользователя и создавать процессы, чтобы выполнить программы, заданные этими командами. Это можно делать использованием fork (см. Раздел 23.4 [Создание Процесса]) и exec (см. Раздел 23.5 [Выполнение Файла]) функций.
Одиночная команда может выполнять только один процесс, но часто одна команда использует отдельные процессы.
Если Вы используете оператор `|' в команде оболочки, Вы явно, запрашиваете несколько программ в их собственных процессах. Но даже если Вы выполняете только одну программу, она может использовать многократные процессы внутренне. Например, одиночная команда трансляции типа " cc -c foo .c " обычно использует четыре процесса. Если Вы выполняете make, ее работа - выполнить другие программы в отдельных процессах.
Процессы, принадлежащие одной команде называются группой процессов или работой. Для того, чтобы Вы могли функционировать на всех сразу. Например, печать C-c посылает сигнал SIGINT, чтобы завершить все процессы в приоритетной группе процессов.
Сеанс - большая группа процессов. Обычно все процессы одиночного входа в систему принадлежат тому же самому сеансу.
Каждый процесс принадлежит группе процессов. Когда процесс создан, он становится элементом той же самой группы процессов и сеанса как и родительский процесс. Вы можете помещать его в другую группу процессов, используя setpgid функцию, если группа процессов принадлежит тому же самому сеансу.
Единственый способ поместить процесс в другой сеанс состоит в том, чтобы сделать его начальным процессом нового сеанса или лидером сеанса, используя setsid функцию. Она также помещает лидера сеанса в новую группу процессов, и Вы не можете перемещать его вне этой группы процессов снова.
Обычно, новые сеансы создаются программой входа в систему, и лидер сеанса - процесс, выполняющий оболочку входа в систему пользователя.
Оболочка, которая поддерживает управление заданиями, должна знать, которая работа может использовать терминал в любое время. Иначе имелось бы сразу много работ, пробующих читать из терминала, и беспорядок относительно того, который процесс должен получить ввод, печатаемый пользователем. Чтобы предотвращать это, оболочка должна сотрудничать с драйвером терминала, используя протокол, описанный в этой главе.
Оболочка может давать безграничный доступ к терминалу управления только одной группы процессов одновременно. Она называется приоритетной работой на этом терминале. Другие группы процессов, управляемые оболочкой, которые выполняются без такого доступа к терминалу, называются фоновыми работами.
Если фоновая работа нуждается в чтении из или записи на терминал управления, она остановлена драйвером терминала. Пользователь может останавливать приоритетную работу, печатая символ SUSP (см. Раздел 12.4.9 [Специальные Символы]) и программа может останавливать любую работу, посылая ей сигнал SIGSTOP. Ответственность оболочки - обратить внимание на останов работ, сообщать пользователю относительно них, и обеспечивать механизмы для разрешения пользователю в интерактивном режиме продолжить остановленные работы и переключать работы между проритетной и фоновыми.
См. Раздел 24.4 [Доступ к Терминалу], для получения более подробной информации о терминале управления,
Не все операционные системы поддерживают управление заданиями. Система GNU поддерживает управление заданиями, но если Вы используете библиотеку GNU на некоторой другой системе, эта система может не поддерживать управление заданиями непосредственно.
Вы можете использовать _POSIX_JOB_CONTROL макрокоманду, чтобы проверить в во время компиляции, поддерживает ли система управление заданиями. См. Раздел 27.2 [Опции Системы].
Если управление заданиями не обеспечивается, то может быть только одна группа процессов на сеанс, который ведет себя, как будто он всегда приоритетный. Функции для создания дополнительных групп процессов просто терпят неудачу с кодом ошибки ENOSYS.
макрокоманды, именующие различные сигналы управления заданиями (см. Раздел 21.2.5 [Сигналы Управления заданиями]) определены, даже если управление заданиями не обеспечивается.
Один из атрибутов процесса - терминал управления. Дочерние процессы, созданные с fork наследуют терминал управления из их родительского процесса. Таким образом,, все процессы в сеансе наследуют терминал управления от лидера сеанса. Лидер сеанса, который имеет контроль над терминалом, называется процессом управления этого терминала.
Вы вообще не должны волноваться относительно точного механизма, используемого, чтобы зарезервировать терминал управления сеанса, так как это выполнено для Вас системой когда Вы входите в систему.
Индивидуальный процесс отделяется от терминала управления, когда это вызывает setsid, чтобы стать лидером нового сеанса. См. Раздел 24.7.2 [Функции Группы процессов].
Процессы в приоритетной работе терминала управления имеют неограниченный доступ к этому терминалу; а фоновые процессы - нет. Этот раздел описывает более подробно, что случается, когда процесс в фоновой работе пробует обращаться к терминалу управления.
Когда процесс в фоновой работе пробует читать из терминала управления, группе процессов обычно послан сигнал SIGTTIN. Это обычно заставляет все процессы в той группе останавливаться (если они не обрабатывают сигнал и не останавливают себя). Однако, если процесс считывания игнорирует или блокирует этот сигнал, то происходит сбои read с EIO ошибкой.
Аналогично, когда процесс в фоновой работе пробует писать на терминал управления, заданное по умолчанию поведение - послать сигнал SIGTTOU группе процессов. Однако, поведение изменяется TOSTOP битом флагов автономных режимов (см. Раздел 12.4.7 [Автономные режимы]). Если этот бит не установлен (по умолчанию), то запись на терминал управления всегда разрешается без сигнала. Запись также разрешается, если сигнал SIGTTOU игнорируется или блокируется процессом записи.
Большинство других операций терминала, которые программа может делать, обрабатываются как чтение или как запиись. (Описание каждой операции должно говорить как.)
Когда процесс управления завершается, терминал становится свободным, и на нем может быть установлен новый сеанс. (Фактически, другой пользователь мог бы войти в систему на терминале.) Это может вызывать проблему, если любые процессы из старого сеанса все еще пробуют использовать этот терминал.
Чтобы предотвратить проблемы, группы процессов, которые продолжают выполняться даже после завершения лидера сеанса, отмечены как свободные группы процессов. Процессы в свободной группе процессов не могут читать из или писать на терминал управления. Это вызовет EIO ошибку.
Когда группа процессов становится свободной, процессам послан сигнал SIGHUP. Обычно, это заставляет процессы завершиться. Однако, если программа игнорирует этот сигнал или устанавливает обработчик для него (см. Главу 21 [Обработка Сигнала] ), она может продолжать выполнять свободную группу процессов даже после того, как процесс управления завершается.
Этот раздел описывает то, что оболочка должна делать, чтобы выполнить управление заданиями, обеспечивая протяженную типовую программу, чтобы проиллюстрировать включаемые понятия.
Все примеры программы, включенные в эту главу - часть простой программы оболочки. Этот раздел представляет структуры данных и сервисные функции, которые используются в примере.
Типовая оболочка имеет дело в основном с двумя структурами данных. Тип job содержит информацию относительно работы, которая является набором подпроцессов, связанных вместе трубопроводами. Тип process содержит информацию относительно одиночного подпроцесса. Имеются релевантные объявления структуры данных:
typedef struct process
{
struct process *next;
char **argv;
pid_t pid;
char completed;
char stopped;
int status;
} process;
typedef struct job
{
struct job *next;
char *command;
process *first_process;
pid_t pgid;
char notified;
struct termios tmodes;
int stdin, stdout, stderr;
} job;
job *first_job = NULL;
job *
find_job (pid_t pgid)
{
job *j;
for (j = first_job; j; j = j->next)
if (j->pgid == pgid)
return j;
return NULL;
}
int
job_is_stopped (job *j)
{
process *p;
for (p = j->first_process; p; p = p->next)
if (!p->completed && !p->stopped)
return 0;
return 1;
}
int
job_is_completed (job *j)
{
process *p;
for (p = j->first_process; p; p = p->next)
if (!p->completed)
return 0;
return 1;
}
Когда программа оболочки, которая обычно выполняет управление заданиями, начата, она должна быть внимательна в случае, если она вызвалось из другой оболочки, которая уже делает собственное управление заданиями.
Подоболочка, которая выполняется в интерактивном режиме, должна убедиться, что она была помещена на передний план родительской оболочкой прежде, чем она может давать возможность управлению заданиями непосредственно. Она делает это, получая начальную ID группы процессов с getpgrp функцией, и сравнивая его с ID группы процессов текущей приоритетной работы, связанной с терминалом управления (который может быть восстановлен, использованием функции tcgetpgrp).
Если подоболочка не выполняется как приоритетная работа, она должна остановить себя, посылая сигнал SIGTTIN собственной группе процессов. Она не может произвольно помещаться на передний план; она должна ждать пока пользователь сообщит родительской оболочке сделала это. Если подоболочка продолжена снова, она должна повторить проверку и останов непосредственно снова, если она все еще не на переднем плане.
Если только подоболочка была помещена на передний план родительской оболочкой, она может давать возможность собственному управлению заданиями. Она делает это, вызывая setpgid, чтобы поместить себя в собственную группу процессов, и вызывая tcsetpgrp, чтобы поместить эту группу процессов на передний план.
Когда оболочка дает возможность управлению заданиями, она должна установить себя, чтобы игнорировать все сигналы останова управления заданиями так, чтобы она случайно не остановила себя. Вы можете сделать это, устанавливая действие для всех сигналов останова как SIG_IGN.
Подоболочка, которая выполняется не-в интерактивном режиме, не может и не должна поддерживать управление заданиями. Она должна оставить все процессы, которые она создает в той же самой группе процессов как оболочка непосредственно; это позволяет родительской оболочке обрабатывать не-интерактивную оболочку и дочерние процессы как одиночную работу. Это просто сделать, только не используйте любой из примитивов управления заданиями, но Вы не должны забыть заставить оболочку делать это.
Вот код инициализации для типовой оболочки, который показывает, как сделать все это.
#include <sys/types.h>
#include <termios.h>
#include <unistd.h>
pid_t shell_pgid;
struct termios shell_tmodes;
int shell_terminal;
int shell_is_interactive;
void
init_shell ()
{
shell_terminal = STDIN_FILENO;
shell_is_interactive=isatty(shell_terminal);
if (shell_is_interactive)
{
while (tcgetpgrp (shell_terminal) !=
(shell_pgid = getpgrp ()))
kill (- shell_pgid, SIGTTIN);
signal (SIGINT, SIG_IGN);
signal (SIGQUIT, SIG_IGN);
signal (SIGTSTP, SIG_IGN);
signal (SIGTTIN, SIG_IGN);
signal (SIGTTOU, SIG_IGN);
signal (SIGCHLD, SIG_IGN);
shell_pgid = getpid ();
if (setpgid(shell_pgid,shell_pgid) < 0)
{
perror ("Couldn't put the shell
in its own process group");
exit (1);
}
tcsetpgrp (shell_terminal, shell_pgid);
tcgetattr(shell_terminal,&shell_tmodes);
}
}
Если только оболочка приняла ответственность за выполнение управления заданиями на терминале управления, она может начинать работы в ответ на команды, печатаемые пользователем.
Чтобы создавать процессы в группе процессов, Вы используете те же самые fork и exec, описанные в Разделе 23.2 [Понятия Создания Процесса]. Так как имеются многократные дочерние включаемые процессы, Вы должны быть внимательны, чтобы делать дела в правильном порядке.
Вы имеете два выбора для того, как структурировать дерево родитель - дочерних связей среди процессов. Вы можете либо делать все процессы в группе процессов дочерними процесса оболочки, либо Вы можете делать один процесс в группе предком всех других процессов в той группе. Типовая программа оболочки, обеспеченная в этой главе использует первый подход, потому что это кажется несколько более простым.
При раздвоении процесса, он должен помещаться в новую группу процессов, вызовом setpgid; см. Раздел 24.7.2 [Функции Группы процессов]. Первый процесс в новой группе становится лидером группы процессов, и его ID, становится ID группы процессов.
Оболочка должна также вызвать setpgid, чтобы поместить каждый из дочерних процессов в новую группу процессов.
Имеется потенциальная проблема синхронизации: каждый дочерний процесс должен быть помещен в группу процессов прежде, чем он начинает выполнять новую программу, и оболочка зависит от наличия всех дочерних процессов в группе прежде, чем она продолжает выполняться. Если и дочерние процессы и оболочка вызывает setpgid, это гарантирует, что все будет правильно независимо от того, который процесс принимается за это раньше.
Если работа начинается как приоритетная работа, новая группа процессов также, должна быть помещена на передний план на терминале управления, используя tcsetpgrp. Снова, это должно быть выполнено оболочкой также как и каждым из дочерних процессов, чтобы избежать условий состязания.
Следующая вещь, которую каждый дочерний процесс должен делать, - сбросить действия сигналов.
В течение инициализации, процесс оболочки устанавливает себя, чтобы игнорировать сигналы управления заданиями; см. Раздел 24.6.2 [Инициализация Оболочки]. В результате, любые дочерние процессы, которые он создает, игнорируют эти сигналы наследованием. Это нежелательно, так что каждый дочерний процесс должен явно установить действия для этих сигналов обратно к SIG_DFL после того, как он раздвоено.
Так как оболочки следуют за этим соглашением, приложения могут принимать, что они наследуют правильную обработку этих сигналов из родительского процесса. Но каждое приложение не должно изменять обработку сигналов останова. Приложения, которые отключают нормальную интерпретацию символа SUSP, должны обеспечить некоторый другой механизм для пользователя, чтобы остановить работу. Когда пользователь вызывает этот механизм, программа должна послать сигнал SIGTSTP группе процессов, а не только на процесс непосредственно. См. Раздел 21.6.2 [Передача сигналов Другому Процессу].
В заключение, каждый дочерний процесс должен вызвать exec нормальным способом. Это - также точка, в которой должна быть обработана переадресация стандартного ввода и каналов вывода. См. Раздел 8.8 [Дублирование Описателей], для объяснения того, как делать это.
Вот функция из типовой программы оболочки, которая ответственна за запуск программы. Функция выполняется каждым дочерним процессом немедленно после того, как он был раздвоен оболочкой, и никогда не возвращается.
void
launch_process (process *p, pid_t pgid,
int infile, int outfile, int errfile,
int foreground)
{
pid_t pid;
if (shell_is_interactive)
{
pid = getpid ();
if (pgid == 0) pgid = pid;
setpgid (pid, pgid);
if (foreground)
tcsetpgrp (shell_terminal, pgid);
signal (SIGINT, SIG_DFL);
signal (SIGQUIT, SIG_DFL);
signal (SIGTSTP, SIG_DFL);
signal (SIGTTIN, SIG_DFL);
signal (SIGTTOU, SIG_DFL);
signal (SIGCHLD, SIG_DFL);
}
if (infile != STDIN_FILENO)
{
dup2 (infile, STDIN_FILENO);
close (infile);
}
if (outfile != STDOUT_FILENO)
{
dup2 (outfile, STDOUT_FILENO);
close (outfile);
}
if (errfile != STDERR_FILENO)
{
dup2 (errfile, STDERR_FILENO);
close (errfile);
}
execvp (p->argv[0], p->argv);
perror ("execvp");
exit (1);
}
Вот функция, что фактически начинает полную работу. После создания дочерних процессов, эта функция вызывает некоторые другие функции, чтобы поместить недавно созданную работу на передний план (или как фон); они обсуждены в Разделе 24.6.4 [Приоритетный и Фоновые].
void
launch_job (job *j, int foreground)
{
process *p;
pid_t pid;
int mypipe[2], infile, outfile;
infile = j->stdin;
for (p = j->first_process; p; p = p->next)
{
if (p->next)
{
if (pipe (mypipe) < 0)
{
perror ("pipe");
exit (1);
}
outfile = mypipe[1];
}
else
outfile = j->stdout;
pid = fork ();
if (pid == 0)
launch_process(p, j->pgid,infile,
outfile, j->stderr,
foreground);
else if (pid < 0)
{
perror ("fork");
exit (1);
}
else
{
p->pid = pid;
if (shell_is_interactive)
{
if (!j->pgid)
j->pgid = pid;
setpgid (pid, j->pgid);
}
}
if (infile != j->stdin)
close (infile);
if (outfile != j->stdout)
close (outfile);
infile = mypipe[0];
}
format_job_info (j, "launched");
if (!shell_is_interactive)
wait_for_job (j);
else if (foreground)
put_job_in_foreground (j, 0);
else
put_job_in_background (j, 0);
}
Теперь давайте рассматривать, какие же действия должны предприниматься оболочкой, когда она начинает приоритетную работу (на переднем плане), и как это отличается от того, что должно быть выполнено, когда начинается фоновая работа.
Когда начинается приоритетная работа, оболочка должна сначала дать ей доступ к терминалу управления, вызывая tcsetpgrp. Затем, оболочка должна ждать завершения или останова процессов в этой группе процессов. Это обсуждено более подробно в Разделе 24.6.5 [Останов и Завершенные Работы].
Когда все процессы в группе завершились или остановились, оболочка должна восстановить контроль над терминалом для собственной группы процессов, вызывая tcsetpgrp снова. Так как сигналы останова вызванны вводом - выводом из фонового процесса или символом SUSP, печатаемым пользователем посланы группе процессов, обычно все процессы работы останавливаются вместе.
Приоритетная работа может оставить терминал в странном состоянии, так что оболочка должна восстановить собственные сохраненные режимы терминала перед продолжением. В случае, если работа просто остановлена, оболочка должна сначала сохранить текущие режимы терминала так, чтобы она могла восстанавливать их позже, если работа будет продолжена. Функции для обработки режимов терминала - tcgetattr и tcsetattr; они описаны в Разделе 12.4 [Режимы Терминала].
Вот функция оболочки для выполнения всего этого.
void
put_job_in_foreground (job *j, int cont)
{
tcsetpgrp (shell_terminal, j->pgid);
if (cont)
{
tcsetattr (shell_terminal, TCSADRAIN,
&j->tmodes);
if (kill (- j->pgid, SIGCONT) < 0)
perror ("kill (SIGCONT)");
}
wait_for_job (j);
tcsetpgrp (shell_terminal, shell_pgid);
tcgetattr (shell_terminal, &j->tmodes);
tcsetattr (shell_terminal, TCSADRAIN,
&shell_tmodes);
}
Вот функция, которая должна быть выполнена, чтобы поместить работу в фон:
void
put_job_in_background (job *j, int cont)
{
if (cont)
if (kill (-j->pgid, SIGCONT) < 0)
perror ("kill (SIGCONT)");
}
Когда начат приоритетный процесс, оболочка должна блокироваться, пока все процессы в этой работе не завершились или не остановились. Она может делать это, вызывая waitpid функцию; см. Раздел 23.6 [Завершение Процесса]. Используйте WUNTRACED опцию, чтобы состояние было сообщено и для процессов, что останавливаются, и для процессов, которые завершаются.
Оболочка должна также проверить состояния фоновых работ так, чтобы она могла сообщать о завершении или останове работы пользователю; это может быть выполнено вызовом waitpid с WNOHANG опцией. Хорошее место, чтобы поместить такую проверку для завершенных и остановленных работ - перед запросом новой команды.
Оболочка может также получать асинхронное уведомление, что имелась информация состояния дочернего процесса, устанавливая обработчик для сигналов SIGCHLD. См. Главу 21 [Обработка Сигнала].
В типовой программе оболочки, сигнал SIGCHLD обычно игнорируется. Чтобы избежать проблемы повторной входимости включая обработку глобальных данных структурировали оболочку. Но в определенных местах, когда оболочка не использует эти структуры данных, например, когда она ждет ввод на терминале, имеет смысл давать возможность обработчику для SIGCHLD. Та же самая функция, которая используется, чтобы делать синхронные проверки состояния может также вызываться изнутри этого обработчика.
Имеются части типовой программы оболочки, которые имеют дело с проверкой состояния работ и сообщением информации пользователю.
int
mark_process_status (pid_t pid, int status)
{
job *j;
process *p;
if (pid > 0)
{
for (j = first_job; j; j = j->next)
for (p =j->first_process; p ;p=p->next)
if (p->pid == pid)
{
p->status = status;
if (WIFSTOPPED (status))
p->stopped = 1;
else
{
p->completed = 1;
if (WIFSIGNALED (status))
fprintf (stderr, "%d:
Terminated by
signal %d.\n",
(int) pid,
WTERMSIG (p->status));
}
return 0;
}
fprintf (stderr, "No child
process %d.\n", pid);
return -1;
}
else if (pid==0 || errno==ECHILD)
return -1;
else {
perror ("waitpid");
return -1;
}
}
void
update_status (void)
{
int status;
pid_t pid;
do
pid = waitpid (WAIT_ANY, &status,
WUNTRACED|WNOHANG);
while (!mark_process_status (pid, status));
}
void
wait_for_job (job *j)
{
int status;
pid_t pid;
do
pid = waitpid (WAIT_ANY, &status, WUNTRACED);
while (!mark_process_status (pid, status)
&& !job_is_stopped (j)
&& !job_is_completed (j));
}
void
format_job_info (job *j, const char *status)
{
fprintf (stderr, "%ld (%s): %s\n", (long)j->pgid,
status, j->command);
}
void
do_job_notification (void)
{
job *j, *jlast, *jnext;
process *p;
update_status ();
jlast = NULL;
for (j = first_job; j; j = jnext)
{
jnext = j->next;
if (job_is_completed (j)) {
format_job_info (j, "completed");
if (jlast)
jlast->next = jnext;
else
first_job = jnext;
free_job (j);
}
else if (job_is_stopped (j) && !j->notified) {
format_job_info (j, "stopped");
j->notified = 1;
jlast = j;
}
else
jlast = j;
}
}
Оболочка может продолжать остановленную работу, посылая сигнал SIGCONT группе процессов. Если работа продолжается на переднем плане, оболочка должна сначала вызвать tcsetpgrp, чтобы дать работе доступ к терминалу и восстановить сохраненные установки терминала. После продолжения работы на переднем плане, оболочка должна ждать останова или завершения работы, как будто работа только что была начата в переднем плане.
Типовая программа оболочки обрабатывает, и недавно созданные и непрерывные работы той же самой парой функций, put_job_in_foreground и put_job_in_background. Определения этих функций были даны в Разделе 24.6.4 [Приоритетный и Фоновые]. При продолжении остановленной работы, значение отлично от нуля передано как cont аргумент, чтобы гарантировать, что сигнал SIGCONT послан и режимы терминала установлены соответствующе.
Осталась только функция для модификации внутреннего состояния оболочки относительно продолжаемой работы:
void
mark_job_as_running (job *j)
{
Process *p;
for (p = j->first_process; p; p = p->next)
p->stopped = 0;
j->notified = 0;
}
void
continue_job (job *j, int foreground)
{
mark_job_as_running (j);
if (foreground)
put_job_in_foreground (j, 1);
else
put_job_in_background (j, 1);
}
Извлечения кода для типовой оболочки, включенные в эту главу - только часть всей программы оболочки. В частности ничто вообще не упоминалось относительно того, как размещена и инициализируется работа и структуры данных программы.
Более реальные оболочки обеспечивают сложный интерфейс пользователя, который имеет поддержку для языка команд; переменные; сокращения, замены, и сопоставление с образцом для имен файлов; и т.п.. Все это слишком сложно, чтобы объяснить здесь! Взамен, мы сконцентрировались на показе создания core-файла процесса и функций управления заданиями, которые могут вызываться из такой оболочки.
Вот таблица, подводящая итог основных точек входа, которые мы обеспечили:
void init_shell (void)
void launch_job (job *j, int foreground)
void do_job_notification (void)
void continue_job (job *j, int foreground)
Конечно, реальная оболочка также должна бы обеспечивать другие функции для управления работами. Например, было бы полезно иметь команды, чтобы перечислить все текущие задания или послать сигнал (типа SIGKILL) к работе.
Этот раздел содержит детализированные описания функций в отношении управления заданиями.
Вы можете использовать ctermid функцию, чтобы получить имя файла, которое Вы можете использовать, чтобы открыть терминал управления. В библиотеке GNU, она возвращает ту же самую строку все время: "/dev/tty". Это - специальное "волшебное" имя файла, которое относится к терминалу управления текущего процесса (если он его имеет). Функция ctermid объявлена в заглавном файле " stdio.h ".
char * ctermid (char *string) (функция)
Пустая строка возвращена, если имя файла не может быть определено по любой причине. Даже если имя файла возвращено, доступ к файлу, который она представляет, не гарантируется.
int L_ctermid (макрос)
См. также isatty и ttyname функции, в Разделе 12.1 [Терминал Ли Это].
Имеются описания функций для управления группами процессов. Ваша программа должна включить заглавные файлы " sys/types.h " и " unistd.h " чтобы использовать эти функции.
pid_t setsid (void) (функция)
Эта функция также заставит вызывающий процесс не иметь никакого терминал управления.
Setsid функция возвращает ID новой группы процессов в случае успеха. Возвращаемое значение -1 указывает ошибку. Следующие errno условия ошибки определены для этой функции:
Вызывающий процесс - уже лидер группы процессов, или имеется уже другая группа процессов, которая имеет тот же самый ID группы процессов.
pid_t getpgrp (void) (POSIX.1 функция)
pid_t getpgrp (pid_t pid) (BSD функция)
int setpgid (pid_t pid, pid_t pgid) (функция)
Эта функция терпит неудачу на системе, которая не поддерживает управление заданиями. См. Раздел 24.2 [Управление Заданиями Необязательно !], для подробной информации.
Если операция является успешной, setpgid, возвращает нуль. Иначе она возвращает -1. Следующие errno условия ошибки определены для этой функции:
Дочерний процесс, именованный pid выполнил функцию exec после раздвоения.
Значение pgid не допустимо.
Система не поддерживает управление заданиями.
Процесс, обозначенный pid аргументом - лидер сеанса, или не в том же самом сеансе как вызывающий процесс, или значение pgid аргумента не соответствует ID группы процессов в том же самом сеансе как вызывающий процесс.
Процесс, обозначенный pid аргументом - не вызывающий процесс или дочерний из вызывающего процесса.
int setpgrp (pid_t pid, pid_t pgid) (функция)
Это функции для чтения или установки группы приоритетного процесса терминала. Вы должны включить заглавные файлы " sys/types.h " и " unistd.h " в вашем приложении, чтобы использовать эти функции.
Хотя эти функции берут аргумент-описатель файла, чтобы определить устройство терминала, приоритетная работа связана с файлом терминала непосредственно, а не с описателем открытого файла.
pid_t tcgetpgrp (int filedes) (функция)
Если нее никакой приоритетной группы процессов, возвращаемое значение - число больше чем 1, которое не соответствует ни одному ID любой существующей группы процессов. Это может случаться, если все процессы в работе, которая была прежде приоритетная работа, завершились, и никакая другая работа не переместилась на передний план.
В случае ошибки возвращается значение -1. Следующие errno условия ошибки определены для этой функции:
Filedes аргумент - не допустимый описатель файла.
Система не поддерживает управление заданиями.
Файл терминала, связанный с filedes аргументом не есть Терминал управления вызывающего процесса.
int tcsetpgrp (int filedes, pid_t pgid) (функция)
Для целей доступа к терминалу, эта функция обрабатывается как вывод. Если она вызывается из фонового процесса на терминале управления, обычно всем процессам в группе процессов, послан сигнал SIGTTOU. Исключение - если вызывающий процесс непосредственно игнорирует или блокирует сигналы SIGTTOU, когда операция выполняется, и никакой сигнал не послан.
При успехе tcsetpgrp возвращает 0. Возвращаемое значение -1 указывает ошибку. Следующие errno условия ошибки определены для этой функции:
Filedes аргумент - не допустимый описатель файла.
Pgid аргумент не допустим.
Система не поддерживает управление заданиями.
Filedes не терминал управления вызывающего процесса.
Pgid не группа процессов в том же самом сеансе как вызывающий процесс.
Каждый пользователь, кто может войти в систему, идентифицирован уникальным числом называемым пользовательский ID.
Каждый процесс имеет эффективный пользовательский ID, который говорит, какие права доступа пользователя он имеет.
Пользователи классифицированы в группы для целей управления доступом. Каждый процесс имеет одно или большее количество значений ID группы, которые говорят, которую группу процесс может использовать для доступа к файлам.
Эффективные пользовательский ID и групповой ID процесса формируют persona(владельца) процесса. Он определяет, к которым файлам процесс может обращаться. Обычно, процесс наследует persona из родительского процесса, но при специальных обстоятельствах, процесс может изменять persona и таким образом изменять права доступа.
Каждый файл в системе также имеет пользовательский ID и ID группы. Управление доступом работает, сравнивая ID пользователя и группы файла с таковыми выполняющегося процесса.
Система хранит базу данных всех зарегистрированных пользователей, и другую базу данных всех определенных групп. Имеются библиотечные функции, которые Вы можете использовать, чтобы исследовать эти базы данных.
Каждый пользователь компьютерной системы идентифицирован именем пользователя (или именем входа в систему) и пользовательским ID. Обычно, каждое имя пользователя имеет уникальный пользовательский ID, но возможно для отдельных имен входа в систему, иметь тот же самый пользовательский ID. Пользовательские имена и соответствующий пользовательский IDS сохранены в базе данных, к которой Вы можете обращаться как описано в Разделе 25.12 [База Данных Пользователей].
Пользователи классифицированы на группы. Каждое имя пользователя также принадлежит одной или большему количеству групп, и имеет одну заданную по умолчанию группу. Пользователи - элементы той же самой группы, могут совместно использовать ресурсы (типы файлов) которые не доступны для пользователей - не элементов этой группы. Каждая группа имеет имя группы и ID группы. См. Раздел 25.13 [База Данных Групп], для того, как найти информацию относительно ID группы или имени группы.
В любое время, каждый процесс имеет отдельный пользовательский ID и ID группы, которые определяют привилегии процесса. Они коллективно называются persona процесса, потому что они определяют " кто это " для целей управления доступом. Эти ID также называются эффективным пользовательским ID и эффективным ID группы процесса.
Ваша оболочка входа в систему начинается с persona, который состоит из вашего пользовательского ID и вашего значения ID группы по умолчанию. В нормальных обстоятельствах, все ваши другие процессы наследуют эти значения.
Процесс также имеет реальный пользовательский ID, который идентифицирует пользователя, который создал процесс, и реальный ID группы, который идентифицирует заданную по умолчанию группу этого пользователя. Эти значения не играют роль в управлении доступом, так что мы не рассматриваем их частью persona. Но они - также важны.
И реальный и эффективный пользовательский ID может быть изменен в течение срока службы процесса. См. Раздел 25.3 [Почему Изменяется Persona].
Кроме того, пользователь может принадлежать многим группам, так что persona включает дополнительные ID группы, которые также относятся к правам.
Пользовательский ID процесса также управляет правами для посылки сигналов, используя функцию kill. См. Раздел 21.6.2 [Передача сигналов Другому Процессу].
Наиболее очевидная ситуация, когда процессу необходимо изменить пользователя и/или ID группы - программа входа в систему. Когда вход в систему начинает выполняться, пользовательский ID корневой. Работа должна начать оболочку, чей ID пользователя и группы являются таковыми регистрируемого пользователя. (Чтобы выполнять это полностью, вход в систему должен установить реальный ID пользователя и группы также как persona. Но это - частный случай.)
Более общий случай изменения persona - когда обычный пользователь программирует потребности доступа к ресурсу, который обычно не доступен для пользователя, фактически выполняющего это.
Например, Вы можете иметь файл, который управляется вашей программой, но он не должен читаться или изменяться непосредственно другими пользователями, потому что он осуществляет некоторый протокол блокировки, или потому что Вы хотите сохранять целостность или секретность информации, которую он содержит. Этот вид ограниченного доступа может быть выполнен при наличии программы, изменяющей эффективного пользователя или ID группы соответствующего таковому ресурса.
Таким образом, вообразите готовую программу, которая сохраняет очки в файле. Готовая программа непосредственно должна быть способной модифицировать этот файл независимо из того, кто выполняет ее, но если пользователи могут записывать в файл без того, чтобы пройти игру, они могут давать себе любое количество очков, которое они находят приятным. Некоторые люди рассматривают этот нежелательным, или даже предосудительным. Это может быть предотвращено, созданием нового пользовательского ID и имени входа в систему (напр. games) чтобы обладать файлом, и сделать файл перезаписываемым только этим пользователем. Когда готовая программа хочет модифицировать этот файл, она может изменять эффективный пользовательский ID на games. В действительности, программа должна принять persona games, чтобы она могла писать в этот файл.
Способность изменять persona процесса может быть источником ненамеренных нарушений секретности, или даже намеренного неправильного обращения. Из-за потенциальных проблем, замена persona ограничена специальными обстоятельствами.
Вы не можете произвольно устанавливать ваш пользовательский ID или ID группы; только привилегированные процессы могут делать это. Взамен, нормальный способ для программы, чтобы изменить persona состоит в том, чтобы было установлено заранее соглашение изменения специфического пользователя или группы. Это делают функции setuid и setgid битов режима доступа файла. См. Раздел 9.8.5 [Биты Прав].
Когда setuid бит исполняемого файла установлен, выполнение этого файла автоматически изменяет эффективный пользовательский ID на пользователя, который обладает файлом. Аналогично, при выполнении файла, чей setgid бит установлен изменяется эффективный ID группы на группу файла. См. Раздел 23.5 [Выполнение Файла]. Создание файла, который изменяется к специфическому ID пользователz или ID группы таким образом, требует полного доступа к этому пользователю или группе.
См. Раздел 9.8 [Атрибуты Файла], для более общего обсуждения режимов файла и достижимости.
Процесс может всегда изменять эффективный пользовательский (или групповой) ID обратно реальному ID. Программы делают это, чтобы выключить их специальные привилегии, когда они ненужны, что делается для большей ошибкоустойчивости.
Имеются детализированные описания функций для чтения ID пользователя и группы процесса, и реального и эффективного. Чтобы использовать эти средства, Вы должны включить заглавные файлы " sys/types.h " и " unistd.h ".
uid_t (тип данных)
gid_t (тип данных)
uid_t getuid (void) (функция)
gid_t getgid (void) (функция)
uid_t geteuid (void) (функция)
gid_t getegid (void) (функция)
int getgroups (int count, gid_t *groups) (функция)
Если count - 0, то getgroups только возвращает общее число дополнительных групп. Для систем, которые не поддерживают дополнительные группы, это будет всегда 0.
Вот как использовать getgroups для чтения вся ID дополнительных групп:
gid_t *
read_all_groups (void)
{
int ngroups = getgroups (NULL, 0);
gid_t *groups = (gid_t *) xmalloc
(ngroups * sizeof (gid_t));
int val = getgroups (ngroups, groups);
if (val < 0)
{
free (groups);
return NULL;
}
return groups;
}
Этот раздел описывает функции для изменения пользовательского ID (реального и/или эффективного) процесса.
Чтобы использовать эти средства, Вы должны включить заглавные файлы " sys/types.h " и " unistd.h ".
int setuid (uid_t newuid) (функция)
Если процесс не привилегирован, то newuid, должен быть равен реальному пользовательскому ID или сохраненному пользовательскому ID (если система поддерживает возможность _POSIX_SAVED_IDS). В этом случае, setuid устанавливает только эффективный пользовательский ID, а не реальный пользовательский ID.
Setuid функция возвращает значение 0, чтобы указать успешное завершение, и значение -1, чтобы указать ошибку. Следующие errno условия ошибки определены для этой функции:
Значение newuid аргумента недопустимо.
Процесс не имеет соответствующих привилегий.
int setreuid (uid_t ruid, uid_t euid) (функция)
Setreuid функция существует для совместимости с 4.3 UNIX BSD, который не поддерживает сохранение ID. Вы можете использовать эту функцию, чтобы изменять эффективного и реального пользователя процесса. (Привилегированные процессы не ограничены этим специфическим использованием.) если сохраненный ID обеспечивается, Вы должны использовать эту возможность вместо этой функции. См. раздел 25.8 [ВКЛЮЧЕНИЕ/ОТКЛЮЧЕНИЕ Setuid].
Возвращаемое значение - 0 при успехе и -1 при отказе. Следующие errno условия ошибки определены для этой функции:
Процесс не имеет соответствующих привилегий; Вы не имеете прав изменить на заданный ID.
Этот раздел описывает функции для изменения ID группы (реальный и эффективный) процесса. Чтобы использовать эти средства, Вы должны включить заглавные файлы " sys/types.h " и " unistd.h ".
int setgid (gid_t newgid) (функция)
Если процесс не привилегирован, то newgid, должен также быть равен реальному ID группы или сохраненному ID группы. В этом случае, setgid устанавливает только эффективный ID группы, а не реальный ID группы.
Возвращаемые значения и условия ошибки для setgid - такие же как для setuid.
int setregid (gid_t rgid, fid_t egid) (функция)
Setregid функция предусмотрена для совместимости с 4.3 UNIX BSD, который не поддерживает сохраненные ID. Вы можете использовать эту функцию, чтобы изменять эффективный и реальный ID группы процесса. (Привилегированные процессы не ограничены этим использованием.) если сохраненные ID обеспечиваются, Вы должны использовать эту возможность вместо того, чтобы использовать эту функцию. См. раздел 25.8 [ВКЛЮЧЕНИЕ/ОТКЛЮЧЕНИЕ Setuid].
Возвращаемые значения и условия ошибки для setregid - такие же как для setreuid.
Система GNU также допускает привилегированным процессам, изменять их дополнительные ID группы. Чтобы использовать setgroups или initgroups, ваши программы должны включить заглавный файл " grp.h ". int setgroups (size_t count, gid_t *groups) (функция)
Эта функция устанавливает дополнительный ID группы процесса. Она может вызываться только из привилегированных процессов. Аргумент count определяет число ID групп в массиве groups.
Эта функция возвращает 0 в случае успеха и -1 при ошибке. Следующие errno условия ошибки определены для этой функции:
Вызывающий процесс не привилегирован.
int initgroups (const char *user, gid_t gid) (функция)
Типичная программа setuid не нуждается в специальном доступе все время. Хорошая идея выключить этот доступ, когда он ненужен, так что она возможно не может давать непривелегированный доступ.
Если система поддерживает сохраненный пользовательский ID, Вы можете выполнить это с setuid. Когда стартует программа game, ее реальный пользовательский ID - jdoe, эффективный пользовательский ID - games, и сохраненный пользовательский ID - также games. Программа должна записать оба значения пользовательских ID один раз в начале, примерно так:
user_user_id = getuid ();
game_user_id = geteuid ();
setuid (user_user_id);
setuid (game_user_id);
На других системах, которые не поддерживают сохраненный пользовательский ID, Вы можете переключать доступ setuid используя setreuid, чтобы менять реального и эффективного пользователя процесса, следующим образом:
setreuid (geteuid (), getuid ());
Почему это имеет эффект переключения доступа setuid? Предположите, что программа game только что началась, и реальный пользовательский ID - jdoe, в то время как эффективный пользовательский ID - games. В этом состоянии, game может запись файл scores (очков). Если она меняет два универсальных идентификатора, реальный, становится games, а эффективный становится jdoe; теперь программа имеет только jdoe доступ. Другая перестановка приводит games обратно к эффективному пользовательскому ID и восстанавливает доступ к файлу scores.
Чтобы обрабатывать оба вида систем, проверьте сохранение пользовательского ID условным выражением препроцессора, примерно так:
#ifdef _POSIX_SAVED_IDS
setuid (user_user_id);
#else
setreuid (geteuid (), getuid ());
#endif
Имеется пример, показывающий, как установить программу, которая изменяет эффективный пользовательский ID.
Это - часть программы game, которая манипулирует файлом " scores " который должен быть перезаписываем только программой game непосредственно. Программа считает, что исполняемый файл будет установлен с set-user-ID набором битов и принадлежать тому же самому пользователю как " scores " файл.
Исполняемому файлу дается режим 4755, при выполнении его " ls -l " производится вывод подобно:
-rwsr-xr-x 1 games 184422 Jul 30 15:17 caber-toss
Файл scores имеет режим 644:
-rw-r--r-- 1 games 0 Jul 31 15:33 scores
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>
static uid_t euid, ruid;
void
do_setuid (void)
{
int status;
#ifdef _POSIX_SAVED_IDS
status = setuid (euid);
#else
status = setreuid (ruid, euid);
#endif
if (status < 0) {
fprintf (stderr, "Couldn't set uid.\n");
exit (status);
}
}
void
undo_setuid (void)
{
int status;
#ifdef _POSIX_SAVED_IDS
status = setuid (ruid);
#else
status = setreuid (euid, ruid);
#endif
if (status < 0) {
fprintf (stderr, "Couldn't set uid.\n");
exit (status);
}
}
int
main (void)
{
ruid = getuid ();
euid = geteuid ();
undo_setuid ();
. . .
}
int
record_score (int score)
{
FILE *stream;
char *myname;
do_setuid ();
stream = fopen (SCORES_FILE, "a");
undo_setuid ();
if (stream)
{
myname = cuserid (NULL);
if (score < 0)
fprintf (stream, "%10s: Couldn't
lift the caber.\n", myname);
else
fprintf (stream, "%10s: %d
feet.\n", myname, score);
fclose (stream);
return 0;
}
else
return -1;
}
Для программ setuid возможно дать доступ пользователю, который не предусмотрен фактически, если Вы хотите избежать этого, Вы должны быть внимательны. Имеются некоторые руководящие принципы для предотвращения непредназначенного доступа и уменьшения следствий, когда он происходит:
Вы можете использовать функции, перечисленные в этом разделе, чтобы определить имя входа в систему пользователя, который выполняет процесс, и имя пользователя, который зарегистрирован в текущем сеансе. См. также функцию getuid (см. Раздел 25.5 [Чтение Persona]).
Getlogin функция объявлена в " unistd.h ", в то время как cuserid и L_cuserid объявлены в " stdio.h ".
char * getlogin (void) (функция)
char * cuserid (char *string) (функция)
int L_cuserid (макрос)
Эти функции допускают вашей программе идентифицировать положительно пользователя, кто выполняется или пользователь, кто зарегистрирован в этом сеансе. (Они могут отличиться, когда программы setuid включаются; См. Раздел 25.2 [Процесс Persona].) пользователь не может сделать ничего, чтобы ввести в заблуждение эти функции.
Для большинства целей более полезно использовать переменную среды LOGNAME, чтобы выяснить, кто пользователь. Это более гибко потому что пользователь может устанавливать LOGNAME произвольно. См. Раздел 22.2.2 [Стандартная Среда].
Этот раздел описывает все относительно поиска и просмотра базы данных зарегистрированных пользователей. База данных непосредственно сохраняется в файле " /etc/passwd " на большинстве систем, но на некоторых системах специальный сетевой сервер дает доступ к этому.
Функции и структуры данных для доступа к базе данных пользователей системы объявлены в заглавном файле " pwd.h ".
struct passwd (тип данных)
char *pw_name
char *pw_passwd.
uid_t pw_uid
gid_t pw_gid
char *pw_gecos
char *pw_dir
char *pw_shell
Вы можете искать специфического пользователя, используюя getpwuid или getpwnam. Эти функции объявлены в " pwd.h ".
struct passwd * getpwuid (uid_t uid) (функция)
Пустое значение указателя указывает, что не имеется никакого пользователя в базе данных с пользовательским ID uid.
struct passwd * getpwnam (const char *name) (функция)
Пустое значение указателя указывает, что не имеется никакого пользователя, именованного name.
Этот раздел объясняет, как программа может читать список всех пользователей в системе, по одному пользователю одновременно. Функции, описанные здесь объявлены в " pwd.h ".
Вы можете использовать fgetpwent функцию для чтения входов пользователя из специфического файла.
struct passwd * fgetpwent (FILE *stream) (функция)
Этот поток должен соответствовать файлу в том же самом формате как стандартный файл базы данных паролей. Эта функция исходит из System V.
Способ просматривать все входы в базе данных пользователей - с setpwent, getpwent, и endpwent.
void setpwent (void) (функция)
struct passwd * getpwent (void) (функция)
Она возвращает указатель на вход. Структура статически размещена и перезаписываема при последующих обращениях к getpwent. Вы должны копировать содержимое структуры, если Вы желаете сохранить информацию.
void endpwent (void) (функция)
int putpwent (const struct passwd *p, FILE *stream) (функция)
Эта функция существует для совместимости с SVID. Мы рекомендуем, чтобы Вы избегали использовать ее, потому что она имеет смысл только при условии, что структура struct passwd не имеет никаких элементов за исключением стандартных; на системе, которая обьединяет традиционную базу данных UNIX с другой расширенной информацией относительно пользователей, эта функция неизбежно не учла бы многое из важной информации.
Функция putpwent объявлена в " pwd.h ".
Этот раздел описывает все относительно того, как искать и просмотреть базу данных зарегистрированных групп. База данных непосредственно сохраняется в файле " /etc/group " на большинстве систем, но на некоторых системах, специальное сетевое обслуживание обеспечивает доступ к ней.
Функции и структуры данных для доступа к базе данных групп системы объявлены в заглавном файле " grp.h ".
struct group (тип данных)
char *gr_name
gid_t gr_gid
char **gr_mem
Вы можете искать специфическую группу, используя getgrgid или getgrnam. Эти функции объявлены в " grp.h ".
struct group * getgrgid (gid_t gid) (функция)
Пустой указатель указывает, что не имеется никакой группы с ID gid.
struct group * getgrnam (const char *name) (функция)
Пустой указатель указывает, что нет никакой группы, именованной name.
Этот раздел объясняет, как программа может читать список всех групп в системе, по одной группе одновременно. Функции, описанные здесь объявлены в " grp.h ".
Вы можете использовать fgetgrent функцию, чтобы читать входы группы из специфического файла.
struct group * fgetgrent (FILE *stream) (функция)
Поток должен соответствовать файлу в том же самом формате как стандартный файл базы данных групп.
Способ просматривать все входы в базе данных групп - с setgrent, getgrent, и endgrent.
void setgrent (void) (функция)
struct group * getgrent (void) (функция)
Она возвращает указатель на вход. Структура статически размещена и перезаписываема при последующих обращениях к getgrent. Вы должны копировать содержимое структуры, если Вы желаете сохранить информацию.
void endgrent (void) (функция)
Вот пример программы, показывающий использование функций запроса базы данных системы. Программа печатает некоторую информацию относительно пользователя, выполняющего программу.
#include <grp.h>
#include <pwd.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>
int
main (void)
{
uid_t me;
struct passwd *my_passwd;
struct group *my_group;
char **members;
me = getuid ();
my_passwd = getpwuid (me);
if (!my_passwd)
{
printf ("Couldn't find out about
user %d.\n", (int) me);
exit (EXIT_FAILURE);
}
printf ("I am %s.\n", my_passwd->pw_gecos);
printf ("My login name is %s.\n",
my_passwd->pw_name);
printf ("My uid is %d.\n", (int)
(my_passwd->pw_uid));
printf ("My home directory is %s.\n",
my_passwd->pw_dir);
printf ("My default shell is %s.\n",
my_passwd->pw_shell);
my_group = getgrgid (my_passwd->pw_gid);
if (!my_group)
{
printf ("Couldn't find out about
group %d.\n",
(int) my_passwd->pw_gid);
exit (EXIT_FAILURE);
}
printf ("My default group is %s (%d).\n",
my_group->gr_name,
(int) (my_passwd->pw_gid));
printf ("The members of this group are:\n");
members = my_group->gr_mem;
while (*members)
{
printf (" %s\n", *(members));
members++;
}
return EXIT_SUCCESS;
}
I am Throckmorton Snurd.
My login name is snurd.
My uid is 31093.
My home directory is /home/fsg/snurd.
My default shell is /bin/sh.
My default group is guest (12).
The members of this group are:
friedman
tami
Эта глава описывает функции, которые возвращают информацию относительно специфической машины, тип аппаратных средств, тип программного обеспечения, и имя индивидуальной машины.
Этот раздел объясняет, как идентифицировать специфическую машину, на которой ваша программа выполняется. Идентификация машины состоит из имени главной ЭВМ Internet и адреса Internet; см. Раздел 11.5 [Именное пространство Internet].
Прототипы для этих функций появляются в " unistd.h ". Команды оболочки hostname и hostid работают, вызывая их.
int gethostname (char *name, size_t size) (функция)
Возвращаемое значение - 0 при успехе и -1 при отказе. В библиотеке GNU C gethostname терпит неудачу, если размер не достаточно большой; Вы можете пробовать снова с большим массивом. Следующее errno условие ошибки определено для этой функции:
Аргумент size - меньше чем размер главного имени плюс один.
Gethostname сохраняет начало главного имени в name, даже если главное имя полностью не будет сохранено. Для некоторых целей, усеченное главное имя достаточно. Если так, то Вы можете игнорировать код ошибки.
int sethostname (const char *name, size_t length) (функция)
Возвращаемое значение - 0 при успехе и -1 при отказе. Следующее errno условие ошибки определено для этой функции:
Этот процесс не может устанавливать главное имя, потому что он не привилегирован.
long int gethostid (void) (функция)
int sethostid (long int id) (функция)
Возвращаемое значение - 0 при успехе и -1 при отказе. Следующие errno условия ошибки определено для этой функции:
Этот процесс не может устанавливать главное имя, потому что он не привилегирован.
операционная система не поддерживает установку главного ID. На некоторых системах, главный ID - бессмысленное но уникальное число, жестко закодированное для каждой машины.
Вы можете использовать uname функцию, чтобы выяснить некоторую информацию относительно типа компьютера. Эта функция и связанный тип данных объявлены в заглавном файле " sys/utsname.h ".
struct utsname (тип данных)
char sysname[]
char nodename[]
char release[]
char version[]
char machine[]
Некоторые системы обеспечивают механизм, чтобы опросить ядро непосредственно для этой информации. На системах без такого механизма, библиотека GNU C вносит это поле, основанное на имени конфигурации, которое было определено при формировании и установке библиотеки.
GNU использует имя с тремя частями, чтобы описать конфигурацию системы; три части - центральный процессор, изготовитель и тип системы, и они отделяются подчеркиванием. Любая возможная комбинация трех имен потенциально значима, но большинство таких комбинаций бессмысленно практически и даже значимые не обязательно обеспечиваются любой специфической программой GNU.
Так как значение в machine, как предполагается, описывает только аппаратные средства, оно состоит из первых двух частей имени конфигурации " центральный процессор - изготовитель ". Например:
"sparc-sun", "i386-anything", "m68k-hp", "m68k-sony", "m68k-sun", "mips-dec"
int uname (struct utsname *info) (функция)
-1 указывает ошибку. Единственая возможная ошибка - EFAULT, которую мы обычно не упоминаем, поскольку она - всегда возможна.
Функции и макрокоманды, перечисленные в этой главе дают информацию относительно параметров конфигурации операционной системы, например, ограничений пропускной способности, присутствие необязательных POSIX возможностей, и заданный по умолчанию путь для исполняемых файлов (см. Раздел 27.12 [Строковые Параметры]).
POSIX.1 и POSIX.2 стандарты определяют ряд параметров, которые описывают ограничения пропускной способности системы. Эти ограничения могут быть фиксированные константы для данной операционной системы, или они могут изменяться от машины к машине.
Каждый из следующих параметров ограничения имеет макрокоманду, которая определена в " limits.h " только, если система имеет фиксированное, однородное ограничение для рассматриваемого параметра. Если система позволяет различным файловым системам или файлам иметь различные ограничения, то макрокоманда неопределена; используйте sysconf, чтобы выяснить ограничение, которое применяется в специфическое время на специфической машине. См. Раздел 27.4 [Sysconf].
Каждый из этих параметров также имеет другую макрокоманду, с именем, начинающимся с " _POSIX ", которая дает самое низкое значение, которое ограничению позволяется иметь на любой системе POSIX. См. Раздел 27.5 [Минимумы].
int ARG_MAX
int CHILD_MAX
int OPEN_MAX
int STREAM_MAX
int TZNAME_MAX
Эти макрокоманды ограничений всегда определяются в " limits.h ".
int NGROUPS_MAX
int SSIZE_MAX
Эта макрокоманда определена во всех системах POSIX, т. к. это ограничение никогда не переконфигурируется.
int RE_DUP_MAX (макрос)
Эта макрокоманда определена во всех POSIX.2 системах, т. к. POSIX.2 говорит, что она должна всегда определяться, даже если не имеется никакого специфического наложенного ограничения.
POSIX определяет некоторые системно-специфические опции, которые не все системы POSIX поддерживают. Так как эти опции обеспечиваются в ядре, а не в библиотеке, просто использование библиотек GNU C не гарантирует любой из этих возможностей; это зависит от системы, которую Вы используете.
Вы можете проверять доступность данной опции, используя макрокоманды в этом разделе, вместе с функцией sysconf. макрокоманды определены только, если Вы включаете " unistd.h ".
Для следующих макрокоманд, если макрокоманда определена в " unistd.h ", то опция обеспечивается.
Иначе, опция может или не может обеспечена; используйте sysconf для выяснения. См. Раздел 27.4 [Sysconf].
int _POSIX_JOB_CONTROL (макрос)
int _POSIX_SAVED_IDS (макрос)
Для следующих макрокоманд, если макрокоманда определена в " unistd.h ", то значение указывает, обеспечивается ли опция. Значение -1 означает нет, а любое другое значение означает да. Если макрокоманда не определена, то опция может или не может обеспечиваться; используйте sysconf для выяснения. См. Раздел 27.4 [Sysconf].
int _POSIX2_C_DEV (макрос)
int _POSIX2_FORT_DEV (макрос)
int _POSIX2_FORT_RUN
int _POSIX2_LOCALEDEF (макрос)
int _POSIX2_SW_DEV (макрос)
long int _POSIX_VERSION (макрос)
Примечание Использования: Не пробуйте тестировать поддерживает ли система POSIX, включая " unistd.h " и тогда проверяя, определен ли _POSIX_VERSION. На не - posix системах, это возможно выдаст ошибку, т. к. там нет никакого " unistd.h ". Мы не знаем любого способа, которым Вы можете надежно проверять при трансляции, поддерживает ли ваша целевая система POSIX или существует ли " unistd.h ".
Компилятор GNU C предопределяет символ __ POSIX __, если целевая система - система POSIX. Если Вы не используете любой, другие компиляторы на системах POSIX, проверяя определенный (__ POSIX __) надежно обнаружят такие системы.
long int _POSIX2_C_VERSION (макрос)
Значение этого символа не говорит ничто относительно утилит, установленных на системе.
Примечание Использования: Вы можете использовать эту макрокоманду, чтобы проверить что POSIX.1 библиотека систем поддерживает POSIX.2 также. Любая POSIX.1 система содержит " unistd.h ", так что включайте этот файл и тогда проверяйте defined (_POSIX2_C_VERSION).
Когда ваша система имеет ограничения системы с перестраиваемой конфигурацией, Вы можете использовать функцию sysconf для выяснения значений, которые применяются для любой специфической машины. Функция и связанные константы параметров объявлены в заглавном файле " unistd.h ".
long int sysconf (int parameter) (функция)
Нормальное возвращаемое значение из sysconf - значение, которое Вы запросили. Значение -1 возвращается, если реализация не налагает ограничения, и в случае ошибки.
Следующие errno условия ошибки определены для этой функции:
значение параметра недопустимо.
Имеются символические константы которые используют как аргументы в sysconf. Значения - все целочисленные константы (более специально, значения перечислимого типа).
_SC_ARG_MAX
_SC_CHILD_MAX
_SC_OPEN_MAX
_SC_STREAM_MAX
_SC_TZNAME_MAX
_SC_NGROUPS_MAX
_SC_JOB_CONTROL
_POSIX_JOB_CONTROL.
_SC_SAVED_IDS
_POSIX_SAVED_IDS.
_SC_VERSION
_SC_CLK_TCK
_SC_2_C_DEV
_SC_2_FORT_DEV
_SC_2_FORT_RUN
_SC_2_LOCALEDEF
_SC_2_SW_DEV
_SC_BC_BASE_MAX
_SC_BC_DIM_MAX
_SC_BC_SCALE_MAX
_SC_BC_STRING_MAX
_SC_COLL_WEIGHTS_MAX
_SC_EXPR_NEST_MAX
_SC_LINE_MAX
_SC_EQUIV_CLASS_MAX
_SC_VERSION
_SC_2_VERSION
_SC_PAGESIZE
Мы рекомендуем, чтобы Вы сначала проверили макроопределение для параметра в котором Вы заинтересованы, и вызывали sysconf только, если макрокоманда не определена. Например, вот как проверяют обеспечивается ли управление заданиями:
int
have_job_control (void)
{
#ifdef _POSIX_JOB_CONTROL
return 1;
#else
int value = sysconf (_SC_JOB_CONTROL);
if (value < 0)
fatal (strerror (errno));
return value;
#endif
}
Here is how to get the value of a numeric limit:
int
get_child_max ()
{
#ifdef CHILD_MAX
return CHILD_MAX;
#else
int value = sysconf (_SC_CHILD_MAX);
if (value < 0)
fatal (strerror (errno));
return value;
#endif
}
Имеются названия для POSIX минимальных верхних пределов для параметров ограничений системы.
Смысл этих значений состоит в том, что Вы можете безопасно помещать в эти ограничения без проверки, может ли специфическая система, которую Вы используете принять их.
_POSIX_ARG_MAX
_POSIX_CHILD_MAX
_POSIX_NGROUPS_MAX
_POSIX_OPEN_MAX
_POSIX_SSIZE_MAX
_POSIX_STREAM_MAX
_POSIX_TZNAME_MAX
_POSIX2_RE_DUP_MAX
POSIX.1 стандарт определяет ряд параметров, которые описывают ограничения файловой системы. Система может иметь фиксированное, однородное ограничение для параметра, но это не обычный случай. На большинстве систем, для различных файловых систем (и, для некоторых параметров, даже для различных файлов) имеются различные максимальные ограничения. Например, если Вы используете NFS для устанавливки некоторых файловых систем из других машин.
Каждая из следующих макрокоманд определена в " limits.h " только, если система имеет фиксированное, однородное ограничение для рассматриваемого параметра. Если система позволяет различным файловым системам или файлам иметь различные ограничения, то макрокоманда неопределена; используйте pathconf или fpathconf, чтобы выяснить ограничение, которое применяется к специфическому файлу. См. Раздел 27.9 [Pathconf].
Каждый параметр также имеет другую макрокоманду, с именем, начинающимся с " _POSIX ", которая дает самое низкое значение, которое ограничению позволяется иметь на любой POSIX системе. См. Раздел 27.8 [Минимумы Файла].
int LINK_MAX (макрос)
int MAX_CANON (макрос)
int MAX_INPUT (макрос)
int NAME_MAX (макрос)
int PATH_MAX (макрос)
int PIPE_BUF (макрос)
Это - альтернативные имена макрокоманд.
int MAXNAMLEN (макрос)
int FILENAME_MAX (макрос)
В отличие от PATH_MAX, эта макрокоманда определена, даже если не имеется никакого фактического наложенного ограничения. В таком случае, значение - обычно очень большое количество. Так всегда в системе GNU.
Примечание Использования: Не используйте FILENAME_MAX как размер массива, чтобы сохранить имя файла! Вы не можете возможно делать массив таким большим! Используйте динамическое резервирование (см. Главу 3 [Распределение памяти]).
POSIX определяет некоторые системно-специфические опции в системных вызовах для файлов. Некоторые системы поддерживают эти опции, а другие - нет. Так как эти опции обеспечиваются в ядре, а не в библиотеке, просто использование библиотеки GNU С не гарантирует, что любая из этих возможностей обеспечивается; это зависит от системы, которую Вы используете. Они могут также изменяться между файловыми системами на одиночной машине.
Этот раздел описывает макрокоманды, которые Вы можете проверять, чтобы определить, обеспечивается ли специфическая опция на вашей машине. Если данная макрокоманда определена в " unistd.h ", то значение, говорит обеспечивается ли соответствующая возможность. (Значение -1 указывает нет; любое другое значение указывает да.) если макрокоманда неопределена, это означает специфические файлы могут и не поддерживать эту возможность.
Так как все машины, которые поддерживают библиотеку GNU C также поддерживают NFS, можно делать общее утверждение относительно того, все ли файловые системы поддерживают возможности _POSIX_NO_TRUNC и _POSIX_CHOWN_RESTRICTED. Так что эти имена никогда не определены как макрокоманды в библиотеке GNU C.
int _POSIX_CHOWN_RESTRICTED (макрос)
int _POSIX_NO_TRUNC (макрос)
unsigned char _POSIX_VDISABLE (макрос)
Если одна из этих макрокоманд является неопределенной, это означает что эта опция может быть определена в действительности для некоторых файлов и не определена для других. Чтобы запрашивать относительно специфического файла, вызовите pathconf или fpathconf. См. Раздел 27.9 [Pathconf].
Имеются имена для POSIX минимальных верхних пределов для некоторых из вышеупомянутых параметров.
Смысл этих значений состоит в том, что Вы можете безопасно помещать в эти ограничения без проверки, может ли специфическая система, которую Вы используете принять их.
_POSIX_LINK_MAX
_POSIX_MAX_CANON
_POSIX_MAX_INPUT
_POSIX_NAME_MAX
_POSIX_PATH_MAX
_POSIX_PIPE_BUF
Когда ваша машина позволяет различным файлам иметь различные значения для параметра файловой системы, Вы можете использовать функции в этом разделе, чтобы выяснить значение, которое применяется к любому специфическому файлу.
Эти функции и связанные константы для аргумента parameter объявлены в заглавном файле " unistd.h ".
long int pathconf (const char *filename, int parameter) (функция)
Аргумент parameter должен быть одной из " _PC_ " констант, перечисленных ниже.
Нормальное возвращаемое значение из pathconf - значение, которое Вы запросили. Значение -1 будет возвращено, если реализация не налагает ограничений, и в случае ошибки.
В вышеупомянутом случае, errno не установлена, в то время как в последнем случае, errno установлена, чтобы указать причину проблемы. Так что единственый способ использовать эту функцию robustly состоит в том, чтобы сохранить 0 в errno перед ее вызовом.
Кроме обычных синтаксических ошибок имени файла (см. Раздел 6.2.3 [Ошибки Имени файла]), следующие условия ошибки определены для этой функции:
значение параметра недопустимо, или реализация не поддерживает параметр для специфического файла.
long int fpathconf (int filedes, int parameter) (функция)
Следующие errno условия ошибки определены для этой функции:
filedes аргумент - не допустимый описатель файла.
значение параметра недопустимо, или реализация не поддерживает параметр для специфического файла.
_PC_LINK_MAX
_PC_MAX_CANON
_PC_MAX_INPUT
_PC_NAME_MAX
_PC_PATH_MAX
_PC_PIPE_BUF
_PC_CHOWN_RESTRICTED
_PC_NO_TRUNC
_PC_VDISABLE
POSIX.2 стандарт определяет некоторые ограничения системы, к которым Вы можете обращаться через sysconf, которые относятся к поведению некоторых утилит а не к поведению библиотеки или операционной системы.
Библиотека GNU C определяет макрокоманды для этих ограничений, и sysconf возвращает значения для них, если Вы спрашиваете; но эти значения не передают никакую значимую информацию. Они - просто самые маленькие значения которые POSIX. 2 разрешает.
int BC_BASE_MAX (макрос)
int BC_SCALE_MAX (макрос)
int BC_DIM_MAX (макрос)
int BC_STRING_MAX (макрос)
int BC_DIM_MAX (макрос)
int COLL_WEIGHTS_MAX (макрос)
int EXPR_NEST_MAX (макрос)
int LINE_MAX (макрос)
_POSIX2_BC_BASE_MAX
_POSIX2_BC_DIM_MAX
_POSIX2_BC_SCALE_MAX
_POSIX2_BC_STRING_MAX
_POSIX2_COLL_WEIGHTS_MAX
_POSIX2_EXPR_NEST_MAX
_POSIX2_LINE_MAX
27.12 Строковые Параметры
POSIX. 2 определяет способ получить строковые параметры из операционной системы - функцией confstr:
size_t confstr (int parameter, char *buf, size_t len) (функция)
Нормальное возвращаемое значение из confstr - длина строкового значения, о котором Вы просили. Если Вы обеспечиваете пустой указатель для buf, то confstr, не пробует сохранять строку; она только возвращает длину. Значение 0 указывает ошибку.
Если строка, о которой Вы просили, слишком длинная для буфера (то есть длиньше чем len - 1), то confstr сохраняет только то что помещается (оставляя участок памяти для пустого символа завершения). Вы можете понять, что это случилось, потому что confstr возвращает значение больше чем или равный len.
Следующие errno условия ошибки определены для этой функции:
значение параметра недопустимо.
_CS_PATH значение этого параметра - рекомендуемый заданный по умолчанию путь для поиска исполняемых файлов. Это - путь, который пользователь имеет по умолчанию только после регистрации.
Способ использовать confstr без любого произвольного ограничения строкового размера состоит в том, чтобы вызвать ее дважды: сначала вызвать ее, чтобы получить длину, зарезервировать буфер соответственно, и тогда вызывать confstr снова, чтобы заполнить буфер, примерно так:
char *
get_default_path (void)
{
size_t len = confstr (_CS_PATH, NULL, 0);
char *buffer = (char *) xmalloc (len);
if (confstr (_CS_PATH, buf, len + 1) == 0) {
free (buffer);
return NULL;
}
return buffer;
}
О некоторых средствах, выполненных библиотекой C действительно нужно думать как о части Языка C непосредственно. Эти средства должны быть зарегистрированы в Руководстве Языка C, а не в библиотечном руководстве; но так как мы пока не имеем руководства языка, и документация для этих возможностей пишется, мы издаем его здесь.
Когда вы - пишите программу, часто неплохо поместить проверки в стратегических местах для "невозможных" ошибок или нарушений базисных предположений. Эти проверки полезны при отладке проблем из-за непониманий между различными частями программы.
макрокоманда assert, определенная в заглавном файле " assert.h ", обеспечивает удобный способ прервать программу при печати сообщения относительно того, где в программе была обнаружена ошибка.
Если только Вы думаете, что ваша программа отлажена, Вы можете отключать проверки ошибки, выполняемые макрокомандой assert, перетранслируя с определенной макрокомандой NDEBUG. Это означает что Вы, фактически не должны изменить исходный текст программы, чтобы отключить эти проверки.
Но отключение этих проверок непротиворечивости нежелательно, если они не делают программу значительно медленнее. Большое количество проверок ошибок - хорошо независимо от того, кто выполняет программу.
Знающий пользователь хотел бы иметь аварийный отказ программы, явно, чем возврат ерунды без указания, что что-то неправильно.
void assert (int expression) (макрос)
Если NDEBUG не определен, assert проверяет значение выражения. Если оно является ложным (нулем), assert прерывает программу (см. Раздел 22.3.4 [Прерывание выполнения Программы]) после печати сообщения вида:
`file':linenum: Assertion `expression' failed.
Если макрокоманда препроцессора NDEBUG определена в отметке, где "assert.h " включен, макрокоманда assert не будет делать абсолютно ничего.
Предупреждение: Даже выражение аргумента не будет оценено, если NDEBUG - определен. Так что никогда не используйте assert с аргументами, которые включают побочные эффекты. Например, assert (++ i> 0); является плохой идеей, потому что i не будет увеличена, если NDEBUG определен.
Примечание Использования: средство assert разработано для обнаружения внутренней несогласованности; оно не подходит для сообщения недопустимого ввода или неподходящего использования пользователем программы.
Информация в диагностических сообщениях, напечатанных макрокомандой assert предназначена, чтобы помочь Вам, программисту, прослеживать причину ошибки, но не полезна для сообщения пользователю вашей программы, почему его или ее ввод был недопустим или почему команда не могла быть проведена. Так что Вы не можете использовать assert, чтобы печатать сообщения об ошибках для этих целей.
Более того, ваша программа не должна прерываться когда дан недопустимый ввод, а assert сделала бы это выйдя с состоянием отличным от нуля (см. Раздел 22.3.2 [Состояние Выхода]) после печати сообщений об ошибках.
ANSI C определяет синтаксис для объявления функции, берущей переменное число или тип аргументов. (Такие функции упоминаются как varargs функции или variadic функции.) Однако, язык непосредственно не обеспечивает никакого механизма для таких функций, чтобы обратиться к их не-требуемым аргументам; взамен, Вы используете переменные макрокоманды аргументов, определенные в " stdarg.h ".
Этот раздел описывает, как объявить variadic функции, как написать их, и как вызвать их правильно.
Примечание Совместимости: Намного более старые диалекты C обеспечивают подобный, но несовместимый, механизм для определения функций с переменным числом аргументов, используя " varargs.h ".
Обычные функции C берут фиксированное число аргументов. Когда Вы определяете функцию, Вы определяете тип данных для каждого аргумента. Каждое обращение к функции должно обеспечить ожидаемое число аргументов, с типами, которые могут быть преобразованы в заданные. Таким образом, если функция " foo " объявлена: int foo (int, char*); то Вы должны вызвать ее с двумя аргументами: числом и строковым указателем.
Но некоторые функции выполняют операции, которые могут принимать неограниченное число аргументов.
В некоторых случаях функция может обрабатывать любое число значений, действуя на все из них, как на блок. Например, рассмотрите функцию, которая резервирует одномерный массив через malloc, чтобы содержать заданный набор значений. Эта операция имеет смысл для любого числа значений, если только длина массива соответствует к заданному числу. Без средств для переменных аргументов, Вы были бы должны определять отдельную функцию для каждого возможного размера массива.
Библиотечная функция printf (см. Раздел 7.9 [Форматируемый Вывод]) - пример другого класса функции, где переменные аргументы полезны. Эта функция печатает аргументы (которые могут изменяться в типе также как в числе) при контроле над строкой шаблона формата.
Это причины определить variadic функцию, которая может обрабатывать так много аргументов, как вызывающий оператор выбирает.
Некоторые функции типа open берут фиксированный набор аргументов, но иногда игнорируют несколько последних. Строгая приверженность ANSI C требует, чтобы эти функции были определены как variadic; практически, однако, компилятор GNU C и большинство других компиляторов C допускает Вам определять такую функцию, чтобы брать фиксированный набор аргументов больше чем она может когда-либо использовать и тогда только объявлять функцию как variadic (или не объявлять аргументы вообще!).
Определение и использование variadic функций включает три шага:
Функция, которая принимает переменное число аргументов, должна быть объявлена с прототипом, который говорит это. Вы записываете фиксированные аргументы как обычные, и тогда указываете ". . ." чтобы указать возможность дополнительных аргументов. Синтаксис ANSI C требует по крайней мере одного фиксированного аргумента перед ". . .". Например,
int
func (const char *a, int b, . . .)
{
. . .
}
Обычные фиксированные аргументы имеют индивидуальные имена, и Вы можете использовать эти имена, чтобы обратиться к их значениям. Но необязательные аргументы не имеют никаких имен коме ". . . ". Как Вы может обращаться к ним ?
Единственый способ обращаться к ним - последовательно, в порядке, в котором они написаны, и Вы должны использовать специальные макрокоманды из " stdarg.h " в следующем процессе:
Шаги 1 и 3 должны выполниться в функции, которая принимает необязательные аргументы. Однако, Вы можете передавать va_list переменную как аргумент другой функции и выполнять весь или часть шага 2 там.
Вы можете выполнять всю последовательность из трех шагов несколько раз внутри одного вызова функции. Если Вы хотите игнорировать необязательные аргументы, Вы можете не делать этого.
Вы можете иметь больше чем одну переменную указателя аргумента, если Вы находите приятным. Вы можете инициализировать каждую переменную с va_start, когда Вы пожелаете, и т. д.
Не имеется никакого общего способа для функции, чтобы определить число и тип необязательных аргументов, с которыми она вызывалась.
Один вид соглашения о вызовах должен передать число необязательных аргументов как один из фиксированных аргументов. Это соглашение работает, принимая что все необязательные аргументы имеют тот же самый тип.
Подобный вариант должен иметь один из требуемых аргументов как битовую маску, с битом для каждой возможной цели, для которой необязательный аргумент мог бы быть обеспечен. Вы проверили бы биты в предопределенной последовательности; если бит установлен, выборка значения следующего аргумента, иначе используется значение по умолчанию.
Требуемый аргумент может использоваться как шаблон, чтобы определить и число и типы необязательных аргументов. Аргумент строки формата printf - один пример этого (см. Раздел 7.9.7 [Функции Форматированного Вывода]).
Другая возможность состоит в том, чтобы передать значение " end marker " как последний необязательный аргумент. Например, для функции, которая манипулирует, произвольным числом аргументов указателей, пустой указатель мог бы указывать конец списка параметров. (Она принимает, что пустой указатель иначе не значим для функции.) execl функция работает только этим способом; см. Раздел 23.5 [Выполнение Файла].
Вы не должны писать что-нибудь специальное, когда Вы вызываете variadic функцию. Только запишите аргументы (требуемые аргументы, сопровождаемые необязательными) внутри круглых скобок, отделенные запятыми, как обычно.
В принципе, функции, которые определены, чтобы быть variadic, должны также быть объявлены, чтобы быть variadic использованием прототипа функции всякий раз, когда Вы вызываете их. (См. Раздел A. 2.2.1 [Variadic Прототипы], для того какэто сделать.) Это - потому что некоторые компиляторы C используют различное соглашение о вызовах, чтобы передать тот же самый набор значений аргумента к функции в зависимости от того, берет ли та функция переменные аргументы или фиксированне аргументы.
Но имеются несколько функций, которые чрезвычайно удобно не объявлять как variadic, например open и printf.
Так как прототип не определяет типы для необязательных аргументов, в обращении к variadic функции, заданные по умолчанию поддержки аргумента выполняются на необязательных значениях аргумента. Это означает объекты типа char или short int (или signed, или нет) преобразуются или в int или в unsigned int, соответственно; а объекты float типа - в double тип. Так, если вызывающий оператор передает char как необязательный аргумент, получится int, и функция должна получить его с va_arg (ap, int).
Преобразование требуемых аргументов управляется прототипом функции обычным способом: выражение аргумента преобразовано в объявленный тип аргумента.
Имеются описания макрокоманд, используемых, чтобы отыскать переменные аргументы. Эти макрокоманды определены в заглавном файле " stdarg.h ".
va_list (тип данных)
void va_start (va_list ap, last_required) (макрос)
См. Раздел A.2.3.1 [Старый Varargs], для альтернативного определения va_start в заглавном файле " varargs.h ".
type va_arg (va_list ap, type) (макрос)
Тип значения, возвращенного va_arg - type как определено в обращении. type должен быть само-поддерживающийся тип (не char или short int или float) который соответствует типу фактического аргумента.
void va_end (va_list ap) (макрос)
В библиотеке GNU C, va_end не делает ничего, и Вы не нуждаетесь в его использовании, кроме причин переносимости.
Вот полная типовая функция, которая принимает переменное число аргументов. Первый аргумент функции - число остающихся аргументов, которые складываются и возвращается результат.
#include <stdarg.h>
#include <stdio.h>
int
add_em_up (int count,...)
{
va_list ap;
int i, sum;
va_start (ap, count);
sum = 0;
for (i = 0; i < count; i++)
sum += va_arg (ap, int);
va_end (ap);
return sum;
}
int
main (void)
{
printf ("%d\n", add_em_up (3, 5, 5, 6));
printf ("%d\n", add_em_up (10, 1, 2, 3, 4, 5,
6, 7, 8, 9, 10));
return 0;
}
Раньше ANSI C программисты использовали немного отличное средство для написания variadic функции. Компилятор GNU C все еще поддерживает его; в настоящее время оно более переносимое чем средство ANSI C, так как поддержка для ANSI C все еще не универсальна. Заглавный файл, который определяет традиционное variadic средство называется " varargs.h ".
Использование " varargs.h " почти такое же как использование " stdarg.h ". Не имеется никакого различия в том, как Вы вызываете variadic функцию; См.Раздел A. 2.2.4 [Вызов Variadics]. Единственое различие находится в том, как Вы определяете их. Прежде всего Вы должны использовать синтаксис не-прототипа старого стиля, примерно так:
tree
build (va_alist)
va_dcl
{
va_list p;
va_start (p);
va_alist (макрос)
va_dcl (макрос)
void va_start (va_list ap) (макрос)
Другие макрокоманды аргумента, va_arg и va_end, те же самые в " varargs.h " как и в " stdarg.h "; см. Раздел A. 2.2.5 [Макросы Аргумента].
Это не работает, чтобы включить, и " varargs.h " и " stdarg.h " в той же самой трансляции; они определяют va_start противоречии способами.
Пустой указатель, как гарантируют, не укажет на любой реальный объект. Вы можете назначать ее для любой переменной указателя, так как она имеет тип void *. Обычный способ записи пустого указателя - NULL.
void * NULL (макрос)
Вы можете также использовать 0 или (void *) 0 как нулевые указатели, но использование NULL более чистое, потому что это делает цель константы более очевидной.
Если Вы используете NULL как аргумент функции, то для полной переносимости, Вы должен удостовериться, что функция имеет объявление прототипа. Иначе, если целевая машина имеет два различных представления указателя, компилятор не будет знать которое представление использовать для этого аргумента. Вы можете избежать этой проблемы, явно приводя константу к соответствующему типу указателя, но мы рекомендуем добавить прототип для функции, которую Вы вызываете.
Результат вычитания двух указателей на C - всегда целое число,но точный тип данных изменяется от компилятора к компилятору. Аналогично, тип данных результата sizeof также изменяется между компиляторами. ANSI определяет стандартные побочные результаты исследования для этих двух типов, так что Вы можете обратиться к ним в переносимом режиме. Они определены в заглавном файле " stddef.h ".
ptrdiff_t (тип данных)
Это будет возможно один из стандартных целочисленных со знаком типов (short int, int или long int), но мог бы быть нестандартный тип, который существует только для этой цели.
size_t (тип данных)
Примечание Использования: size_t - привилегированный способ объявить любые аргументы или переменные, которые содержат размер объекта.
В системе GNU size_t эквивалентен или unsigned int или unsigned long int. Эти типы имеют идентичные свойства в системе GNU, и для большинства целей, Вы можете использовать их неизменяя. Однако, они различны как типы данных, что дает различие в некоторых контекстах.
Примечание Совместимости: Реализации C перед появлением ANSI C вообще использовали unsigned int для представления объектных размеров и int для результатов вычитания указателей. Они не обязательно определяли или size_t или ptrdiff_t. Системы UNIX определяли size_t, в " sys/types.h ", но определение было обычно знаковым типом.
Большинство времени, если Вы выбираете соответствующий тип данных для каждого объекта в вашей программе, Вы не должны иметь отношение к тому, как они представляются или сколько битов они используют. Когда Вы нуждаетесь в такой информации, Язык C непосредственно не обеспечивает способ получить это. Заглавные файлы " limits.h " и " float .h " содержит макрокоманды, которые дают Вам эту информацию.
Наиболее общая причина, по которой программа должна знать, сколько битов находятся в целочисленном типе - для использования массива long int как битового вектора. Вы можете обращаться к биту с индексом n как vector[n / LONGBITS] & (1 << (n % LONGBITS)), если Вы определяете LONGBITS как число битов в long int.
Не имеется никакого оператора в Языке C, который может давать Вам число битов в целочисленном типе данных. Но Вы можете вычислять его из макрокоманды CHAR_BIT, определенный в заглавном файле " limits.h ".
CHAR_BIT Это - число битов в char; восемь, на большинстве систем. Значение имеет тип int.
Вы можете вычислять число битов в любом типе данных примерно так:
sizeof (type) * CHAR_BIT
Предположите, что Вы должны сохранить целочисленное значение, которое может быть в промежутке от нуля до одного миллиона. Который тип является самым маленьким типом, который Вы можете использовать? Не имеется никакого общего правила; это зависит от компилятора C и целевой машины. Вы можете использовать " MIN " и " МАX " макрокоманды в " limits.h " чтобы определить, который тип будет работать.
Каждый целочисленный со знаком тип имеет пару макрокоманд, которые дают самые маленькие и самые большие значения, которые он может содержать. Каждый целочисленный беззнаковый тип имеет одну такую макрокоманду, для максимального значения; минимальное значение, конечно - нуль.
Значения этих макрокоманд - все целочисленные постоянные выражения. " MAX " и " MIN " макрокоманды для char и short int имеют значения типа int. " MAX " и " MIN " макрокоманды для других типов имеет значения того же самого типа, описанного макрокомандой таким образом, ULONG_MAX имеет unsigned long int тип.
SCHAR_MIN
SCHAR_MAX
UCHAR_MAX
CHAR_MIN
CHAR_MAX
SHRT_MIN
SHRT_MAX
USHRT_MAX
INT_MIN
INT_MAX
UINT_MAX
LONG_MIN
LONG_MAX
ULONG_MAX
LONG_LONG_MIN
LONG_LONG_MAX
ULONG_LONG_MAX
WCHAR_MAX
Заглавный файл " limits.h " также определяет некоторые дополнительные константы, которые операционная система и файловая система ограничивает. Эти константы описаны в Главе 27 [Конфигурация Системы].
Специфическое представление чисел с плавающей запятой изменяется от машины к машине. Потому что числа с плавающей запятой представляются внутренне как приблизительные количества, алгоритмы для управления данными с плавающей запятой часто должны принять во внимание точные характеристики конкретной машины.
Заглавный файл " float .h " описывает формат, используемый вашей машиной.
A.5.3.1 Концепции Представления Чисел С Плавающей Запятой
Этот раздел представляет терминологию для описания представлений с плавающей запятой.
Вы возможно уже знакомы с большинством этих понятий в терминах научного или экспоненциального представления чисел для чисел с плавающей запятой. Например, число 123456.0 могло бы быть выражено в экспоненциальном представлении как 1.23456e + 05, укорченная запись, указывающая, что мантисса 1.23456 умножена на основание 10 в степени 5.
Более формально, внутреннее представление числа са плавающей запятой может характеризоваться в терминах следующих параметров:
Мантисса числа с плавающей запятой фактически представляет неявную дробь, чей знаменатель является основой в степени точности. Так как самая большая представимая мантисса на один меньше чем этот знаменатель, значение дроби - всегда строго меньше чем 1. Математическое значение числа с плавающей запятой - произведние этой дроби, знака, и основы в стпени экспоненты.
Мы говорим, что число с плавающей запятой нормализовано, если дробь по крайней мере 1/b, где b - основа. Другими словами, мантисса была слишком большая для представления, если она была бы умножена на основу. Не нормализованные числа иногда называются нестандартными; они содержат меньшее количество точности чем представление, обычно может содержать.
Если число не нормализовано, то Вы может вычитать 1 из экспоненты при умножении мантиссы на основу, и получать другое число с плавающей запятой с тем же самым значением. Нормализация состоит из выполнения этого неоднократно, пока число не нормализовано. Два различных нормализованных числа с плавающей запятой не могут быть равны в значении.
К этим макроопределениям можно обращаться, включая заглавный файл " кfloat.h " в вашей программе.
Имена макрокоманд, начинающиеся с " FLT_ " относятся к float типу, в то время как имена, начинающиеся с " DBL_ " обращаются к double типу, а имена, начинающиеся " LDBL_ " относит к long double типу. (В настоящее время GCC не поддерживает long double как отдельный тип данных, так что значения для "LDBL_ " константы равны соответствующим константам для double типа.)
Из этих макрокоманд, только FLT_RADIX, как гарантируют, будет постоянным выражением. Другие макрокоманды, перечисленные здесь не могут надежно использоваться в местах, которые требуют постоянных выражений, типа " #if " директив предварительной обработки или в размерах статических массивов.
Хотя стандарт ANSI C определяет минимальные и максимальные значения для большинства этих параметров, реализация GNU C использует любые значения, описывающие представление с плавающей запятой целевой машины. Так в принципе GNU C фактически удовлетворяет требования ANSI C только, если целевая машина подходящая. Практически, все машины, в настоящее время обеспечиваемые, подходящие.
FLT_ROUNDS
-1 Режим - неопределенный
0 Округление к нулю.
1 Округление к самому близкому числу.
2 Округление к положительной бесконечности.
3 Округление к отрицательной бесконечности.
На большинстве машин, значение 1, в соответствии с стандартом ИИЭРа для чисел с плавающей запятой.
Вот таблица, показывающая, как некоторые значения округляются для каждого возможного значения FLT_ROUNDS.
0 1 2 3
1.00000003 1.0 1.0 1.00000012 1.0
1.00000007 1.0 1.00000012 1.00000012 1.0
-1.00000003 -1.0 -1.0 -1.0 -1.00000012
-1.00000007 -1.0 -1.00000012 -1.0 -1.00000012
FLT_RADIX
FLT_MANT_DIG
float radix = FLT_RADIX;
1.0f + 1.0f / radix / radix / . . . / radix
DBL_MANT_DIG
LDBL_MANT_DIG
FLT_DIG
Значение этой макрокоманды, как предполагается, является по крайней мере 6, для удовлетворения ANSI C.
DBL_DIG
LDBL_DIG
FLT_MIN_EXP
DBL_MIN_EXP
LDBL_MIN_EXP
FLT_MIN_10_EXP
DBL_MIN_10_EXP
LDBL_MIN_10_EXP
FLT_MAX_EXP
DBL_MAX_EXP
LDBL_MAX_EXP
FLT_MAX_10_EXP
DBL_MAX_10_EXP
LDBL_MAX_10_EXP
FLT_MAX
Самое маленькое представимое число - -FLT_MAX.
DBL_MAX
LDBL_MAX
FLT_MIN
DBL_MIN
LDBL_MIN
FLT_EPSILON
DBL_EPSILON
LDBL_EPSILON
Вот пример, показывающий, как размеры типа с плавающей запятой выступают в поддержку наиболее общего представления с плавающей запятой, заданного ИИЭР Стандартом для Двоичной Арифметики С плавающей запятой (ANSI/IEEE Std 754-1985). Почти все компьютеры, разработанные начиная с 1980 ого используют этот формат.
ИИЭР представление float с одинарной точностью использует основание 2. Имеется знаковый разряд, мантисса с 23 битами плюс один скрытый бит (так что общая точность - 24 2-ичные цифры), и экспонента с 8 битами, которая может представлять значения в промежутке от -125 до 128, включительно.
Так, для реализации, которая использует, это представление для типа данных float, соответствующие значения для соответствующих параметров:
FLT_RADIX 2
FLT_MANT_DIG 24
FLT_DIG 6
FLT_MIN_EXP -125
FLT_MIN_10_EXP -37
FLT_MAX_EXP 128
FLT_MAX_10_EXP +38
FLT_MIN 1.17549435E-38F
FLT_MAX 3.40282347E+38F
FLT_EPSILON 1.19209290E-07F
DBL_MANT_DIG 53
DBL_DIG 15
DBL_MIN_EXP -1021
DBL_MIN_10_EXP -307
DBL_MAX_EXP 1024
DBL_MAX_10_EXP 308
DBL_MAX 1.7976931348623157E+308
DBL_MIN 2.2250738585072014E-308
DBL_EPSILON 2.2204460492503131E-016
Вы можете использовать offsetof, чтобы измерить расположение внутри структурного типа специфического элемента структуры.
size_t offsetof (type, member) (макрос)
Эта макрокоманда не будет работать, если элемент - битовое поле; Вы получаете ошибку из компилятора C в этом случае.
Это приложение - полный список средств, объявленных внутри заглавных файлов, обеспеченных библиотекой GNU C. Каждый вход также перечисляет стандарт или другой источник, из которого каждое средство получено, и сообщает Вам, где в руководстве Вы можете найти более подробную информацию.
void abort (void)
`stdlib.h' (ANSI): Раздел 22.3.4 [Прерывание выполнения Программы].
int abs (int number)
`stdlib.h' (ANSI): Раздел 14.3 [Абсолютное Значение].
int accept (int socket, struct sockaddr *addr, size_t *length`ptr)
`sys/socket.h' (BSD): Раздел 11.8.3 [Принятие Соединений].
int access (const char *filename, int how)
`unistd.h' (POSIX.1): Раздел 9.8.8 [Прверка Прав Файла].
double acosh (double x)
`math.h' (BSD): Раздел 13.5 [Гиперболические функции].
double acos (double x)
`math.h' (ANSI): Раздел 13.3 [Обратные Тригонометрические Функции].
int adjtime (const struct timeval *delta, struct timeval *olddelta)
`sys/time.h' (BSD): Раздел 17.2.2 [Точный Календарь].
AF_FILE
`sys/socket.h' (GNU): Раздел 11.3.1 [Форматы Адреса].
AF_INET
`sys/socket.h' (BSD): Раздел 11.3.1 [Форматы Адреса].
AF_UNIX
`sys/socket.h' (BSD): Раздел 11.3.1 [Форматы Адреса].
AF_UNSPEC
`sys/socket.h' (BSD): Раздел 11.3.1 [Форматы Адреса].
unsigned int alarm (unsigned int seconds)
`unistd.h' (POSIX.1): Раздел 17.3 [Установка Сигнализации].
void * alloca (size_t size);
`stdlib.h' (GNU, BSD): Раздел 3.5 [Автоматический Размер Переменной].
ALTWERASE
`termios.h' (BSD): Раздел 12.4.7 [Автономные режимы].
int ARG_MAX
`limits.h' (POSIX.1): Раздел 27.1 [Основные Ограничения].
char * asctime (const struct tm *brokentime)
`time.h' (ANSI): Раздел 17.2.4 [Форматирование Даты и Времени].
double asinh (double x)
`math.h' (BSD): Раздел 13.5 [Гиперболические функции].
double asin (double x)
`math.h' (ANSI): Раздел 13.3 [Обратные Тригонометрические Функции].
int asprintf (char **ptr, const char *template, . . .)
`stdio.h' (GNU): Раздел 7.9.8 [Динамический Вывод].
void assert (int expression)
`assert.h' (ANSI): Раздел A.1 [Проверка Внутренней Непротиворечивости].
double atan2 (double y, double x)
`math.h' (ANSI): Раздел 13.3 [Обратные Тригонометрические Функции].
double atanh (double x)
`math.h' (BSD): Раздел 13.5 [Гиперболические функции].
double atan (double x)
`math.h' (ANSI): Раздел 13.3 [Обратные Тригонометрические Функции].
int atexit (void (*function) (void))
`stdlib.h' (ANSI): Раздел 22.3.3 [Очистки на Выходе].
double atof (const char *string)
`stdlib.h' (ANSI): Раздел 14.7.2 [Синтаксический анализ
с Плавающей Точкой].
int atoi (const char *string)
`stdlib.h' (ANSI): Раздел 14.7.1 [Синтаксический анализ Целых чисел].
long int atol (const char *string)
`stdlib.h' (ANSI): Раздел 14.7.1 [Синтаксический анализ Целых чисел].
B0
`termios.h' (POSIX.1): Раздел 12.4.8 [Скорость Строки].
B110
`termios.h' (POSIX.1): Раздел 12.4.8 [Скорость Строки].
B1200
`termios.h' (POSIX.1): Раздел 12.4.8 [Скорость Строки].
B134
`termios.h' (POSIX.1): Раздел 12.4.8 [Скорость Строки].
B150
`termios.h' (POSIX.1): Раздел 12.4.8 [Скорость Строки].
B1800
`termios.h' (POSIX.1): Раздел 12.4.8 [Скорость Строки].
B19200
`termios.h' (POSIX.1): Раздел 12.4.8 [Скорость Строки].
B200
`termios.h' (POSIX.1): Раздел 12.4.8 [Скорость Строки].
B2400
`termios.h' (POSIX.1): Раздел 12.4.8 [Скорость Строки].
B300
`termios.h' (POSIX.1): Раздел 12.4.8 [Скорость Строки].
B38400
`termios.h' (POSIX.1): Раздел 12.4.8 [Скорость Строки].
B4800
`termios.h' (POSIX.1): Раздел 12.4.8 [Скорость Строки].
B50
`termios.h' (POSIX.1): Раздел 12.4.8 [Скорость Строки].
B600
`termios.h' (POSIX.1): Раздел 12.4.8 [Скорость Строки].
B75
`termios.h' (POSIX.1): Раздел 12.4.8 [Скорость Строки].
B9600
`termios.h' (POSIX.1): Раздел 12.4.8 [Скорость Строки].
int BC_BASE_MAX
`limits.h' (POSIX.2): Раздел 27.10 [Пределы Утилит].
int BC_DIM_MAX
`limits.h' (POSIX.2): Раздел 27.10 [Пределы Утилит].
int BC_DIM_MAX
`limits.h' (POSIX.2): Раздел 27.10 [Пределы Утилит].
int bcmp (const void *a1, const void *a2, size_t size)
`string.h' (BSD): Раздел 5.5 [Сравнение Строки/Массива].
void * bcopy (void *from, const void *to, size_t size)
`string.h' (BSD): Раздел 5.4 [Копирование и Конкатенация].
int BC_SCALE_MAX
`limits.h' (POSIX.2): Раздел 27.10 [Пределы Утилит].
int BC_STRING_MAX
`limits.h' (POSIX.2): Раздел 27.10 [Пределы Утилит].
int bind (int socket, struct sockaddr *addr, size_t length)
`sys/socket.h' (BSD): Раздел 11.3.2 [Установка Адреса].
BRKINT
`termios.h' (POSIX.1): Раздел 12.4.4 [Режимы Ввода].
_BSD_SOURCE
(GNU): Раздел 1.3.4 [Макрокоманды Возможностей].
void * bsearch (const void *key, const void *array, size_t count,
size_t size, comparison_fn_t compare)
`stdlib.h' (ANSI): Раздел 15.2 [Функции Поиска в Массиве].
int BUFSIZ
`stdio.h' (ANSI): Раздел 7.17.3 [Буферизация Управления].
void * bzero (void *block, size_t size)
`string.h' (BSD): Раздел 5.4 [Копирование и Конкатенация].
double cabs (struct { double real, imag; } z)
`math.h' (BSD): Раздел 14.3 [Абсолютное Значение].
void * calloc (size_t count, size_t eltsize)
`malloc.h', `stdlib.h' (ANSI): Раздел 3.3.5 [Распределение
Очищенного Места].
double cbrt (double x)
`math.h' (BSD): Раздел 13.4 [Экспоненты и Логарифмы].
cc_t
`termios.h' (POSIX.1): Раздел 12.4.1 [Типы Данных Режима Терминала].
CCTS_OFLOW
`termios.h' (BSD): Раздел 12.4.6 [Контрольные Режимы].
double ceil (double x)
`math.h' (ANSI): Раздел 14.5 [Округление и Остаточные члены].
speed_t cfgetispeed (const struct termios *termios`p)
`termios.h' (POSIX.1): Раздел 12.4.8 [Скорость Строки].
speed_t cfgetospeed (const struct termios *termios`p)
`termios.h' (POSIX.1): Раздел 12.4.8 [Скорость Строки].
int cfmakeraw (struct termios *termios`p)
`termios.h' (BSD): Раздел 12.4.8 [Скорость Строки].
void cfree (void *ptr)
`stdlib.h' (Sun): Раздел 3.3.3 [Освобождение После Мalloc].
int cfsetispeed (struct termios *termios`p, speed_t speed)
`termios.h' (POSIX.1): Раздел 12.4.8 [Скорость Строки].
int cfsetospeed (struct termios *termios`p, speed_t speed)
`termios.h' (POSIX.1): Раздел 12.4.8 [Скорость Строки].
int cfsetspeed (struct termios *termios`p, speed_t speed)
`termios.h' (BSD): Раздел 12.4.8 [Скорость Строки].
CHAR_BIT
`limits.h' (ANSI): Раздел A.5.1 [Ширина Типа].
CHAR_MAX
`limits.h' (ANSI): Раздел A.5.2 [Диапазон Типа].
CHAR_MIN
`limits.h' (ANSI): Раздел A.5.2 [Диапазон Типа].
int chdir (const char *filename)
`unistd.h' (POSIX.1): Раздел 9.1 [Рабочий Каталог].
int CHILD_MAX
`limits.h' (POSIX.1): Раздел 27.1 [Основные Ограничения].
int chmod (const char *filename, mode_t mode)
`sys/stat.h' (POSIX.1): Раздел 9.8.7 [Установка Прав].
int chown (const char *filename, uid_t owner, gid_t group)
`unistd.h' (POSIX.1): Раздел 9.8.4 [Владелец Файла].
void clearerr (FILE *stream)
`stdio.h' (ANSI): Раздел 7.13 [EOF и Ошибки].
int CLK_TCK
`time.h' (POSIX.1): Раздел 17.1.1 [Основное Время CPU].
CLOCAL
`termios.h' (POSIX.1): Раздел 12.4.6 [Контрольные Режимы].
clock_t clock (void)
`time.h' (ANSI): Раздел 17.1.1 [Основное Время CPU].
int CLOCKS_PER_SEC
`time.h' (ANSI): Раздел 17.1.1 [Основное Время CPU].
clock_t
`time.h' (ANSI): Раздел 17.1.1 [Основное Время CPU].
int closedir (DIR *dirstream)
`dirent.h' (POSIX.1): Раздел 9.2.3 [Чтение/Закрытие Каталога].
int close (int filedes)
`unistd.h' (POSIX.1): Раздел 8.1 [Открытие и Закрытие Файлов].
int COLL_WEIGHTS_MAX
`limits.h' (POSIX.2): Раздел 27.10 [Пределы Утилит].
size_t confstr (int parameter, char *buf, size_t len)
`unistd.h' (POSIX.2): Раздел 27.12 [Параметры Строки].
int connect (int socket, struct sockaddr *addr, size_t length)
`sys/socket.h' (BSD): Раздел 11.8.1 [Соединение].
cookie_close_function
`stdio.h' (GNU): Раздел 7.18.3.2 [Функции-Ловушки].
cookie_read_function
`stdio.h' (GNU): Раздел 7.18.3.2 [Функции-Ловушки].
cookie_seek_function
`stdio.h' (GNU): Раздел 7.18.3.2 [Функции-Ловушки].
cookie_write_function
`stdio.h' (GNU): Раздел 7.18.3.2 [Функции-Ловушки].
double copysign (double value, double sign)
`math.h' (BSD): Раздел 14.4 [Функции Нормализации].
double cosh (double x)
`math.h' (ANSI): Раздел 13.5 [Гиперболические функции].
double cos (double x)
`math.h' (ANSI): Раздел 13.2 [Тригонометрические Функции].
CREAD
`termios.h' (POSIX.1): Раздел 12.4.6 [Контрольные Режимы].
int creat (const char *filename, mode_t mode)
`fcntl.h' (POSIX.1): Раздел 8.1 [Открытие и Закрытие Файлов].
CRTS_IFLOW
`termios.h' (BSD): Раздел 12.4.6 [Контрольные Режимы].
CS5
`termios.h' (POSIX.1): Раздел 12.4.6 [Контрольные Режимы].
CS6
`termios.h' (POSIX.1): Раздел 12.4.6 [Контрольные Режимы].
CS7
`termios.h' (POSIX.1): Раздел 12.4.6 [Контрольные Режимы].
CS8
`termios.h' (POSIX.1): Раздел 12.4.6 [Контрольные Режимы].
CSIZE
`termios.h' (POSIX.1): Раздел 12.4.6 [Контрольные Режимы].
_CS_PATH
`unistd.h' (POSIX.2): Раздел 27.12 [Параметры Строки].
CSTOPB
`termios.h' (POSIX.1): Раздел 12.4.6 [Контрольные Режимы].
char * ctermid (char *string)
`stdio.h' (POSIX.1): Раздел 24.7.1 [Идентификация Терминала].
char * ctime (const time_t *time)
`time.h' (ANSI): Раздел 17.2.4 [Форматирование Даты и Времени].
char * cuserid (char *string)
`stdio.h' (POSIX.1): Раздел 25.11 [Кто вошел в систему].
int daylight
`time.h' (SVID): Раздел 17.2.6 [Функции для Временной Зоны].
DBL_DIG
`float.h' (ANSI): Раздел A.5.3.2 [Параметры с плвающей точкой].
DBL_EPSILON
`float.h' (ANSI): Раздел A.5.3.2 [Параметры с плвающей точкой].
DBL_MANT_DIG
`float.h' (ANSI): Раздел A.5.3.2 [Параметры с плвающей точкой].
DBL_MAX_10_EXP
`float.h' (ANSI): Раздел A.5.3.2 [Параметры с плвающей точкой].
DBL_MAX_EXP
`float.h' (ANSI): Раздел A.5.3.2 [Параметры с плвающей точкой].
DBL_MAX
`float.h' (ANSI): Раздел A.5.3.2 [Параметры с плвающей точкой].
DBL_MIN_10_EXP
`float.h' (ANSI): Раздел A.5.3.2 [Параметры с плвающей точкой].
DBL_MIN_EXP
`float.h' (ANSI): Раздел A.5.3.2 [Параметры с плвающей точкой].
DBL_MIN
`float.h' (ANSI): Раздел A.5.3.2 [Параметры с плвающей точкой].
dev_t
`sys/types.h' (POSIX.1): Раздел 9.8.1 [Значения Атрибутов].
double difftime (time_t time1, time_t time0)
`time.h' (ANSI): Раздел 17.2.1 [Простое Календарное Время].
DIR
`dirent.h' (POSIX.1): Раздел 9.2.2 [Открытие Каталога].
div_t div (int numerator, int denominator)
`stdlib.h' (ANSI): Раздел 14.6 [Целое Деление].
div_t
`stdlib.h' (ANSI): Раздел 14.6 [Целое Деление].
double drem (double numerator, double denominator)
`math.h' (BSD): Раздел 14.5 [Округление и Остаточные члены].
int dup2 (int old, int new)
`unistd.h' (POSIX.1): Раздел 8.8 [Двойные Описатели].
int dup (int old)
`unistd.h' (POSIX.1): Раздел 8.8 [Двойные Описатели].
int E2BIG
`errno.h' (POSIX.1: Argument list too long): Раздел 2.2 [Коды Ошибки].
int EACCES
`errno.h' (POSIX.1: Permission denied): Раздел 2.2 [Коды Ошибки].
int EADDRINUSE
`errno.h' (BSD: Address already in use): Раздел 2.2 [Коды Ошибки].
int EADDRNOTAVAIL
`errno.h' (BSD: Can't assign requested address):
Раздел 2.2[Коды Ошибки].
int EAFNOSUPPORT
`errno.h' (BSD: Address family not supported by protocol family):
Раздел 2.2 [Коды Ошибки].
int EAGAIN
`errno.h' (POSIX.1: Resource temporarily unavailable):
Раздел 2.2 [Коды Ошибки].
int EALREADY
`errno.h' (BSD: Operation already in progress):Раздел 2.2 [Коды Ошибки].
int EBACKGROUND
`errno.h' (GNU: Inappropriate operation for background process):
Раздел 2.2 [Коды Ошибки].
int EBADF
`errno.h' (POSIX.1: Bad file descriptor): Раздел 2.2 [Коды Ошибки].
int EBUSY
`errno.h' (POSIX.1: Device busy): Раздел 2.2 [Коды Ошибки].
int ECHILD
`errno.h' (POSIX.1: No child processes): Раздел 2.2 [Коды Ошибки].
ECHOCTL
`termios.h' (BSD): Раздел 12.4.7 [Автономные режимы].
ECHOE
`termios.h' (POSIX.1): Раздел 12.4.7 [Автономные режимы].
ECHO
`termios.h' (POSIX.1): Раздел 12.4.7 [Автономные режимы].
ECHOKE
`termios.h' (BSD): Раздел 12.4.7 [Автономные режимы].
ECHOK
`termios.h' (POSIX.1): Раздел 12.4.7 [Автономные режимы].
ECHONL
`termios.h' (POSIX.1): Раздел 12.4.7 [Автономные режимы].
ECHOPRT
`termios.h' (BSD): Раздел 12.4.7 [Автономные режимы].
int ECONNABORTED
`errno.h' (BSD: Software caused connection abort):
Раздел 2.2 [Коды Ошибки].
int ECONNREFUSED
`errno.h' (BSD: Connection refused): Раздел 2.2 [Коды Ошибки].
int ECONNRESET
`errno.h' (BSD: Connection reset by peer): Раздел 2.2 [Коды Ошибки].
int EDEADLK
`errno.h' (POSIX.1: Resource deadlock avoided):Раздел 2.2 [Коды Ошибки].
int EDESTADDRREQ
`errno.h' (BSD: Destination address required): Раздел 2.2 [Коды Ошибки].
int ED
`errno.h' (GNU: ?): Раздел 2.2 [Коды Ошибки].
int EDOM
`errno.h' (ANSI: Numerical argument out of domain):
Раздел 2.2 [Коды Ошибки].
int EDQUOT
`errno.h' (BSD: Disc quota exceeded): Раздел 2.2 [Коды Ошибки].
int EEXIST
`errno.h' (POSIX.1: File exists): Раздел 2.2 [Коды Ошибки].
int EFAULT
`errno.h' (POSIX.1: Bad address): Раздел 2.2 [Коды Ошибки].
int EFBIG
`errno.h' (POSIX.1: File too large): Раздел 2.2 [Коды Ошибки].
int EGRATUITOUS
`errno.h' (GNU: Gratuitous error): Раздел 2.2 [Коды Ошибки].
int EGREGIOUS
`errno.h' (GNU: You really blew it this time): Раздел 2.2 [Коды Ошибки].
int EHOSTDOWN
`errno.h' (BSD: Host is down): Раздел 2.2 [Коды Ошибки].
int EHOSTUNREACH
`errno.h' (BSD: No route to host): Раздел 2.2 [Коды Ошибки].
int EIEIO
`errno.h' (GNU: Computer bought the farm): Раздел 2.2 [Коды Ошибки].
int EINPROGRESS
`errno.h' (BSD: Operation now in progress): Раздел 2.2 [Коды Ошибки].
int EINTR
`errno.h' (POSIX.1: Interrupted system call): Раздел 2.2 [Коды Ошибки].
int EINVAL
`errno.h' (POSIX.1: Invalid argument): Раздел 2.2 [Коды Ошибки].
int EIO
`errno.h' (POSIX.1: Input/output error): Раздел 2.2 [Коды Ошибки].
int EISCONN
`errno.h' (BSD: Socket is already connected): Раздел 2.2 [Коды Ошибки].
int EISDIR
`errno.h' (POSIX.1: Is a directory): Раздел 2.2 [Коды Ошибки].
int ELOOP
`errno.h' (BSD: Too many levels of symbolic links):
Раздел 2.2 [Коды Ошибки].
int EMFILE
`errno.h' (POSIX.1: Too many open files): Раздел 2.2 [Коды Ошибки].
int EMLINK
`errno.h' (POSIX.1: Too many links): Раздел 2.2 [Коды Ошибки].
int EMSGSIZE
`errno.h' (BSD: Message too long): Раздел 2.2 [Коды Ошибки].
int ENAMETOOLONG
`errno.h' (POSIX.1: File name too long): Раздел 2.2 [Коды Ошибки].
void endgrent (void)
`grp.h' (SVID, BSD): Раздел 25.13.3 [Просмотр Всех Групп].
void endhostent ()
`netdb.h' (BSD): Раздел 11.5.2.4 [Главные Имена].
void endnetent (void)
`netdb.h' (BSD): Раздел 11.12 [База данных Сетей].
void endprotoent (void)
`netdb.h' (BSD): Раздел 11.5.6 [База данных Протоколов].
void endpwent (void)
`pwd.h' (SVID, BSD): Раздел 25.12.3 [Просмотр Всех Пользователей].
void endservent (void)
`netdb.h' (BSD): Раздел 11.5.4 [База Данных Услуг].
int ENETDOWN
`errno.h' (BSD: Network is down): Раздел 2.2 [Коды Ошибки].
int ENETRESET
`errno.h' (BSD: Network dropped connection on reset):
Раздел 2.2 [Коды Ошибки].
int ENETUNREACH
`errno.h' (BSD: Network is unreachable): Раздел 2.2 [Коды Ошибки].
int ENFILE
`errno.h' (POSIX.1: Too many open files in system):
Раздел 2.2 [Коды Ошибки].
int ENOBUFS
`errno.h' (BSD: No buffer space available): Раздел 2.2 [Коды Ошибки].
int ENODEV
`errno.h' (POSIX.1: Operation not supported by device):
Раздел 2.2 [Коды Ошибки].
int ENOENT
`errno.h' (POSIX.1: No such file or directory):
Раздел 2.2 [Коды Ошибки].
int ENOEXEC
`errno.h' (POSIX.1: Exec format error): Раздел 2.2 [Коды Ошибки].
int ENOLCK
`errno.h' (POSIX.1: No locks available): Раздел 2.2 [Коды Ошибки].
int ENOMEM
`errno.h' (POSIX.1: Cannot allocate memory): Раздел 2.2 [Коды Ошибки].
int ENOPROTOOPT
`errno.h' (BSD: Protocol not available): Раздел 2.2 [Коды Ошибки].
int ENOSPC
`errno.h' (POSIX.1: No space left on device): Раздел 2.2 [Коды Ошибки].
int ENOSYS
`errno.h' (POSIX.1: Function not implemented): Раздел 2.2 [Коды Ошибки].
int ENOTBLK
`errno.h' (BSD: Block device required): Раздел 2.2 [Коды Ошибки].
int ENOTCONN
`errno.h' (BSD: Socket is not connected): Раздел 2.2 [Коды Ошибки].
int ENOTDIR
`errno.h' (POSIX.1: Not a directory): Раздел 2.2 [Коды Ошибки].
int ENOTEMPTY
`errno.h' (POSIX.1: Directory not empty): Раздел 2.2 [Коды Ошибки].
int ENOTSOCK
`errno.h' (BSD: Socket operation on non-socket):
Раздел 2.2 [Коды Ошибки].
int ENOTTY
`errno.h' (POSIX.1: Inappropriate ioctl for device):
Раздел 2.2 [Коды Ошибки].
char ** environ
`unistd.h' (POSIX.1): Раздел 22.2.1 [Доступ Среды].
int ENXIO
`errno.h' (POSIX.1: Device not configured): Раздел 2.2 [Коды Ошибки].
int EOF
`stdio.h' (ANSI): Раздел 7.13 [EOF и Ошибки].
int EOPNOTSUPP
`errno.h' (BSD: Operation not supported): Раздел 2.2 [Коды Ошибки].
int EPERM
`errno.h' (POSIX.1: Operation not permitted): Раздел 2.2 [Коды Ошибки].
int EPFNOSUPPORT
`errno.h' (BSD: Protocol family not supported):
Раздел 2.2 [Коды Ошибки].
int EPIPE
`errno.h' (POSIX.1: Broken pipe): Раздел 2.2 [Коды Ошибки].
int EPROTONOSUPPORT
`errno.h' (BSD: Protocol not supported): Раздел 2.2 [Коды Ошибки].
int EPROTOTYPE
`errno.h' (BSD: Protocol wrong type for socket):
Раздел 2.2 [Коды Ошибки].
int EQUIV_CLASS_MAX
`limits.h' (POSIX.2): Раздел 27.10 [Пределы Утилит].
int ERANGE
`errno.h' (ANSI: Numerical result out of range): Раздел 2.2 [Коды Ошибки].
int EREMOTE
`errno.h' (BSD: Too many levels of remote in path):
Раздел 2.2 [Коды Ошибки].
int EROFS
`errno.h' (POSIX.1: Read-only file system): Раздел 2.2 [Коды Ошибки].
volatile int errno
`errno.h' (ANSI): Раздел 2.1 [Проверка Ошибок].
int ESHUTDOWN
`errno.h' (BSD: Can't send after socket shutdown):
Раздел 2.2 [Коды Ошибки].
int ESOCKTNOSUPPORT
`errno.h' (BSD: Socket type not supported): Раздел 2.2 [Коды Ошибки].
int ESPIPE
`errno.h' (POSIX.1: Illegal seek): Раздел 2.2 [Коды Ошибки].
int ESRCH
`errno.h' (POSIX.1: No such process): Раздел 2.2 [Коды Ошибки].
int ESTALE
`errno.h' (BSD: Stale NFS file handle): Раздел 2.2 [Коды Ошибки].
int ETIMEDOUT
`errno.h' (BSD: Connection timed out): Раздел 2.2 [Коды Ошибки].
int ETXTBSY
`errno.h' (BSD: Text file busy): Раздел 2.2 [Коды Ошибки].
int EUSERS
`errno.h' (BSD: Too many users): Раздел 2.2 [Коды Ошибки].
int EWOULDBLOCK
`errno.h' (BSD: Operation would block): Раздел 2.2 [Коды Ошибки].
int EXDEV
`errno.h' (POSIX.1: Invalid cross-device link): Раздел 2.2 [Коды Ошибки].
int execle (const char *filename, const char *arg0,
char *const env[], . . .)
`unistd.h' (POSIX.1): Раздел 23.5 [Выполнение Файла].
int execl (const char *filename, const char *arg0, . . .)
`unistd.h' (POSIX.1): Раздел 23.5 [Выполнение Файла].
int execlp (const char *filename, const char *arg0, . . .)
`unistd.h' (POSIX.1): Раздел 23.5 [Выполнение Файла].
int execve (const char *filename, char *const argv[],
char *const env[])
`unistd.h' (POSIX.1): Раздел 23.5 [Выполнение Файла].
int execv (const char *filename, char *const argv[])
`unistd.h' (POSIX.1): Раздел 23.5 [Выполнение Файла].
int execvp (const char *filename, char *const argv[])
`unistd.h' (POSIX.1): Раздел 23.5 [Выполнение Файла].
int EXIT_FAILURE
`stdlib.h' (ANSI): Раздел 22.3.2 [Состояние Выхода].
void exit (int status)
`stdlib.h' (ANSI): Раздел 22.3.1 [Нормальное Завершение].
void _exit (int status)
`unistd.h' (POSIX.1): Раздел 22.3.5 [Внутренняя организация Окончания].
int EXIT_SUCCESS
`stdlib.h' (ANSI): Раздел 22.3.2 [Состояние Выхода].
double exp (double x)
`math.h' (ANSI): Раздел 13.4 [Экспоненты и Логарифмы].
double expm1 (double x)
`math.h' (BSD): Раздел 13.4 [Экспоненты и Логарифмы].
int EXPR_NEST_MAX
`limits.h' (POSIX.2): Раздел 27.10 [Пределы Утилит].
double fabs (double number)
`math.h' (ANSI): Раздел 14.3 [Абсолютное Значение].
int fchmod (int filedes, int mode)
`sys/stat.h' (BSD): Раздел 9.8.7 [Установка Прав].
int fchown (int filedes, int owner, int group)
`unistd.h' (BSD): Раздел 9.8.4 [Владелец Файла].
int fclean (FILE *stream)
`stdio.h' (GNU): Раздел 8.5.3 [Очистка Потоков].
int fclose (FILE *stream)
`stdio.h' (ANSI): Раздел 7.4 [Закрытие Потоков].
int fcntl (int filedes, int command, . . .)
`fcntl.h' (POSIX.1): Раздел 8.7 [Контрольные Операции].
int FD_CLOEXEC
`fcntl.h' (POSIX.1): Раздел 8.9 [Дескрипторные Флаги].
void FD_CLR (int filedes, fd_set *set)
`sys/types.h' (BSD): Раздел 8.6 [Ожидание Ввода/Вывода].
int FD_ISSET (int filedes, fd_set *set)
`sys/types.h' (BSD): Раздел 8.6 [Ожидание Ввода/Вывода].
FILE * fdopen (int filedes, const char *opentype)
`stdio.h' (POSIX.1): Раздел 8.4 [Описатели и Потоки].
void FD_SET (int filedes, fd_set *set)
`sys/types.h' (BSD): Раздел 8.6 [Ожидание Ввода/Вывода].
fd_set
`sys/types.h' (BSD): Раздел 8.6 [Ожидание Ввода/Вывода].
int FD_SETSIZE
`sys/types.h' (BSD): Раздел 8.6 [Ожидание Ввода/Вывода].
int F_DUPFD
`fcntl.h' (POSIX.1): Раздел 8.8 [Двойные Описатели].
void FD_ZERO (fd_set *set)
`sys/types.h' (BSD): Раздел 8.6 [Ожидание Ввода/Вывода].
int feof (FILE *stream)
`stdio.h' (ANSI): Раздел 7.13 [EOF и Ошибки].
int ferror (FILE *stream)
`stdio.h' (ANSI): Раздел 7.13 [EOF и Ошибки].
int fflush (FILE *stream)
`stdio.h' (ANSI): Раздел 7.17.2 [Промывка Буферов].
int fgetc (FILE *stream)
`stdio.h' (ANSI): Раздел 7.6 [Символьный Ввод].
int F_GETFD
`fcntl.h' (POSIX.1): Раздел 8.9 [Дескрипторные Флаги].
int F_GETFL
`fcntl.h' (POSIX.1): Раздел 8.10 [Флаги Состояния Файла].
struct group * fgetgrent (FILE *stream)
`grp.h' (SVID): Раздел 25.13.3 [Просмотр Всех Групп].
int F_GETLK
`fcntl.h' (POSIX.1): Раздел 8.11 [Блокировки Файла].
int F_GETOWN
`fcntl.h' (BSD): Раздел 8.12 [Прерванный Ввод].
int fgetpos (FILE *stream, fpos_t *position)
`stdio.h' (ANSI): Раздел 7.16 [Переносное Позиционирование].
struct passwd * fgetpwent (FILE *stream)
`pwd.h' (SVID): Раздел 25.12.3 [Просмотр Всех Пользователей].
char * fgets (char *s, int count, FILE *stream)
`stdio.h' (ANSI): Раздел 7.7 [Строчный Ввод].
FILE
`stdio.h' (ANSI): Раздел 7.1 [Потоки].
int FILENAME_MAX
`stdio.h' (ANSI): Раздел 27.6 [Ограничения для Файлов].
int fileno (FILE *stream)
`stdio.h' (POSIX.1): Раздел 8.4 [Описатели и Потоки].
int finite (double x)
`math.h' (BSD): Раздел 14.2 [Предикаты на Float].
double floor (double x)
`math.h' (ANSI): Раздел 14.5 [Округление и Остаточные члены].
FLT_DIG
`float.h' (ANSI): Раздел A.5.3.2 [Параметры с плвающей точкой].
FLT_EPSILON
`float.h' (ANSI): Раздел A.5.3.2 [Параметры с плвающей точкой].
FLT_MANT_DIG
`float.h' (ANSI): Раздел A.5.3.2 [Параметры с плвающей точкой].
FLT_MAX_10_EXP
`float.h' (ANSI): Раздел A.5.3.2 [Параметры с плвающей точкой].
FLT_MAX_EXP
`float.h' (ANSI): Раздел A.5.3.2 [Параметры с плвающей точкой].
FLT_MAX
`float.h' (ANSI): Раздел A.5.3.2 [Параметры с плвающей точкой].
FLT_MIN_10_EXP
`float.h' (ANSI): Раздел A.5.3.2 [Параметры с плвающей точкой].
FLT_MIN_EXP
`float.h' (ANSI): Раздел A.5.3.2 [Параметры с плвающей точкой].
FLT_MIN
`float.h' (ANSI): Раздел A.5.3.2 [Параметры с плвающей точкой].
FLT_RADIX
`float.h' (ANSI): Раздел A.5.3.2 [Параметры с плвающей точкой].
FLT_ROUNDS
`float.h' (ANSI): Раздел A.5.3.2 [Параметры с плвающей точкой].
FLUSHO
`termios.h' (BSD): Раздел 12.4.7 [Автономные режимы].
FILE * fmemopen (void *buf, size_t size, const char *opentype)
`stdio.h' (GNU): Раздел 7.18.1 [Строковые Потоки].
double fmod (double numerator, double denominator)
`math.h' (ANSI): Раздел 14.5 [Округление и Остаточные члены].
int fnmatch (const char *pattern, const char *string, int flags)
`fnmatch.h' (POSIX.2): Раздел 16.1 [Свободное Соответствие].
FNM_CASEFOLD
`fnmatch.h' (GNU): Раздел 16.1 [Свободное Соответствие].
FNM_FILE_NAME
`fnmatch.h' (GNU): Раздел 16.1 [Свободное Соответствие].
FNM_LEADING_DIR
`fnmatch.h' (GNU): Раздел 16.1 [Свободное Соответствие].
FNM_NOESCAPE
`fnmatch.h' (POSIX.2): Раздел 16.1 [Свободное Соответствие].
FNM_PATHNAME
`fnmatch.h' (POSIX.2): Раздел 16.1 [Свободное Соответствие].
FNM_PERIOD
`fnmatch.h' (POSIX.2): Раздел 16.1 [Свободное Соответствие].
int F_OK
`unistd.h' (POSIX.1): Раздел 9.8.8 [Прверка Прав Файла].
FILE * fopencookie (void *cookie, const char *opentype,
struct cookie_functions io`functions)
`stdio.h' (GNU): Раздел 7.18.3.1 [Потоки и Cookie].
FILE * fopen (const char *filename, const char *opentype)
`stdio.h' (ANSI): Раздел 7.3 [Открытие Потоков].
int FOPEN_MAX
`stdio.h' (ANSI): Раздел 7.3 [Открытие Потоков].
pid_t fork (void)
`unistd.h' (POSIX.1): Раздел 23.4 [Создание Процесса].
long int fpathconf (int filedes, int parameter)
`unistd.h' (POSIX.1): Раздел 27.9 [Pathconf].
FPE_DECOVF_TRAP
`signal.h' (BSD): Раздел 21.2.1 [Сигналы Ошибки в Программе].
FPE_FLTDIV_FAULT
`signal.h' (BSD): Раздел 21.2.1 [Сигналы Ошибки в Программе].
FPE_FLTDIV_TRAP
`signal.h' (BSD): Раздел 21.2.1 [Сигналы Ошибки в Программе].
FPE_FLTOVF_FAULT
`signal.h' (BSD): Раздел 21.2.1 [Сигналы Ошибки в Программе].
FPE_FLTOVF_TRAP
`signal.h' (BSD): Раздел 21.2.1 [Сигналы Ошибки в Программе].
FPE_FLTUND_FAULT
`signal.h' (BSD): Раздел 21.2.1 [Сигналы Ошибки в Программе].
FPE_FLTUND_TRAP
`signal.h' (BSD): Раздел 21.2.1 [Сигналы Ошибки в Программе].
FPE_INTDIV_TRAP
`signal.h' (BSD): Раздел 21.2.1 [Сигналы Ошибки в Программе].
FPE_INTOVF_TRAP
`signal.h' (BSD): Раздел 21.2.1 [Сигналы Ошибки в Программе].
FPE_SUBRNG_TRAP
`signal.h' (BSD): Раздел 21.2.1 [Сигналы Ошибки в Программе].
fpos_t
`stdio.h' (ANSI): Раздел 7.16 [Переносное Позиционирование].
int fprintf (FILE *stream, const char *template, . . .)
`stdio.h' (ANSI): Раздел 7.9.7 [Функции Форматированного Вывода].
int fputc (int c, FILE *stream)
`stdio.h' (ANSI): Раздел 7.5 [Простой Вывод].
int fputs (const char *s, FILE *stream)
`stdio.h' (ANSI): Раздел 7.5 [Простой Вывод].
F_RDLCK
`fcntl.h' (POSIX.1): Раздел 8.11 [Блокировки Файла].
size_t fread (void *data, size_t size, size_t count, FILE *stream)
`stdio.h' (ANSI): Раздел 7.12 [Блокирование Вывода/Вывода].
__free_hook
`malloc.h' (GNU): Раздел 3.3.9 [Ловушки для Malloc].
void free (void *ptr)
`malloc.h', `stdlib.h' (ANSI): Раздел 3.3.3 [Освобождение после Malloc].
FILE * freopen (const char *filename, const char *opentype,
FILE *stream)
`stdio.h' (ANSI): Раздел 7.3 [Открытие Потоков].
double frexp (double value, int *exponent)
`math.h' (ANSI): Раздел 14.4 [Функции Нормализации].
int fscanf (FILE *stream, const char *template, . . .)
`stdio.h' (ANSI): Раздел 7.11.8 [Функции Форматированного Ввода].
int fseek (FILE *stream, long int offset, int whence)
`stdio.h' (ANSI): Раздел 7.15 [Позиционирование Файла].
int F_SETFD
`fcntl.h' (POSIX.1): Раздел 8.9 [Дескрипторные Флаги].
int F_SETFL
`fcntl.h' (POSIX.1): Раздел 8.10 [Флаги Состояния Файла].
int F_SETLK
`fcntl.h' (POSIX.1): Раздел 8.11 [Блокировки Файла].
int F_SETLKW
`fcntl.h' (POSIX.1): Раздел 8.11 [Блокировки Файла].
int F_SETOWN
`fcntl.h' (BSD): Раздел 8.12 [Прерванный Ввод].
int fsetpos (FILE *stream, const fpos_t position)
`stdio.h' (ANSI): Раздел 7.16 [Переносное Позиционирование].
int fstat (int filedes, struct stat *buf )
`sys/stat.h' (POSIX.1): Раздел 9.8.2 [Чтение Атрибутов].
long int ftell (FILE *stream)
`stdio.h' (ANSI): Раздел 7.15 [Позиционирование Файла].
F_UNLCK
`fcntl.h' (POSIX.1): Раздел 8.11 [Блокировки Файла].
size_t fwrite (const void *data, size_t size, size_t count,
FILE *stream)
`stdio.h' (ANSI): Раздел 7.12 [Блокирование Вывода/Вывода].
F_WRLCK
`fcntl.h' (POSIX.1): Раздел 8.11 [Блокировки Файла].
int getchar (void)
`stdio.h' (ANSI): Раздел 7.6 [Символьный Ввод].
int getc (FILE *stream)
`stdio.h' (ANSI): Раздел 7.6 [Символьный Ввод].
char * getcwd (char *buffer, size_t size)
`unistd.h' (POSIX.1): Раздел 9.1 [Рабочий Каталог].
ssize_t getdelim (char **lineptr, size_t *n, int delimiter,
FILE *stream)
`stdio.h' (GNU): Раздел 7.7 [Строчный Ввод].
gid_t getegid (void)
`unistd.h' (POSIX.1): Раздел 25.5 [Чтение Persona].
char * getenv (const char *name)
`stdlib.h' (ANSI): Раздел 22.2.1 [Доступ Среды].
uid_t geteuid (void)
`unistd.h' (POSIX.1): Раздел 25.5 [Чтение Persona].
gid_t getgid (void)
`unistd.h' (POSIX.1): Раздел 25.5 [Чтение Persona].
struct group * getgrent (void)
`grp.h' (SVID, BSD): Раздел 25.13.3 [Просмотр Всех Групп].
struct group * getgrgid (gid_t gid)
`grp.h' (POSIX.1): Раздел 25.13.2 [Поиск Группы].
struct group * getgrnam (const char *name)
`grp.h' (SVID, BSD): Раздел 25.13.2 [Поиск Группы]].
int getgroups (int count, gid_t *groups)
`unistd.h' (POSIX.1): Раздел 25.5 [Чтение Persona].
struct hostent * gethostbyaddr (const char *addr, int length,
int format)
`netdb.h' (BSD): Раздел 11.5.2.4 [Главные Имена].
struct hostent * gethostbyname (const char *name)
`netdb.h' (BSD): Раздел 11.5.2.4 [Главные Имена].
struct hostent * gethostent ()
`netdb.h' (BSD): Раздел 11.5.2.4 [Главные Имена].
long int gethostid (void)
`unistd.h' (BSD): Раздел 26.1 [Главная Идентификация].
int gethostname (char *name, size_t size)
`unistd.h' (BSD): Раздел 26.1 [Главная Идентификация].
int getitimer (int which, struct itimerval *old)
`sys/time.h' (BSD): Раздел 17.3 [Установка Сигнализации].
ssize_t getline (char **lineptr, size_t *n, FILE *stream)
`stdio.h' (GNU): Раздел 7.7 [Строчный Ввод].
char * getlogin (void)
`unistd.h' (POSIX.1): Раздел 25.11 [Кто вошел в систему].
struct netent * getnetbyaddr (long net, int type)
`netdb.h' (BSD): Раздел 11.12 [База данных Сетей].
struct netent * getnetbyname (const char *name)
`netdb.h' (BSD): Раздел 11.12 [База данных Сетей].
struct netent * getnetent (void)
`netdb.h' (BSD): Раздел 11.12 [База данных Сетей].
int getopt (int argc, char **argv, const char *options)
`unistd.h' (POSIX.2): Раздел 22.1.2 [Синтаксический анализ Опций].
int getopt_long (int argc, char **argv, const char *shortopts,
struct option *longopts, int *indexptr)
`getopt.h' (GNU): Раздел 22.1.4 [Длинные Опции].
int getpeername (int socket, struct sockaddr *addr, size_t *length`ptr)
`sys/socket.h' (BSD): Раздел 11.8.4 [Кто на Связи].
pid_t getpgrp (pid_t pid)
`unistd.h' (BSD): Раздел 24.7.2 [Функции Группы Процессов].
pid_t getpgrp (void)
`unistd.h' (POSIX.1): Раздел 24.7.2 [Функции Группы Процессов].
pid_t getpid (void)
`unistd.h' (POSIX.1): Раздел 23.3 [Идентификация Процесса].
pid_t getppid (void)
`unistd.h' (POSIX.1): Раздел 23.3 [Идентификация Процесса].
int getpriority (int class, int id)
`sys/resource.h' (BSD): Раздел 17.7 [Приоритет].
struct protoent * getprotobyname (const char *name)
`netdb.h' (BSD): Раздел 11.5.6 [База данных Протоколов].
struct protoent * getprotobynumber (int protocol)
`netdb.h' (BSD): Раздел 11.5.6 [База данных Протоколов].
struct protoent * getprotoent (void)
`netdb.h' (BSD): Раздел 11.5.6 [База данных Протоколов].
struct passwd * getpwent (void)
`pwd.h' (POSIX.1): Раздел 25.12.3 [Просмотр Всех Пользователей].
struct passwd * getpwnam (const char *name)
`pwd.h' (POSIX.1): Раздел 25.12.2 [Поиск Пользователя].
struct passwd * getpwuid (uid_t uid)
`pwd.h' (POSIX.1): Раздел 25.12.2 [Поиск Пользователя].
int getrlimit (int resource, struct rlimit *rlp)
`sys/resource.h' (BSD): Раздел 17.6 [Ограничения Ресурсов].
int getrusage (int processes, struct rusage *rusage)
`sys/resource.h' (BSD): Раздел 17.5 [Использование Ресурсов].
struct servent * getservbyname (const char *name, const char *proto)
`netdb.h' (BSD): Раздел 11.5.4 [База Данных Услуг].
struct servent * getservbyport (int port, const char *proto)
`netdb.h' (BSD): Раздел 11.5.4 [База Данных Услуг].
struct servent * getservent (void)
`netdb.h' (BSD): Раздел 11.5.4 [База Данных Услуг].
char * gets (char *s)
`stdio.h' (ANSI): Раздел 7.7 [Строчный Ввод].
int getsockname (int socket, struct sockaddr *addr, size_t *length`ptr)
`sys/socket.h' (BSD): Раздел 11.3.3 [Чтение Адреса].
int getsockopt (int socket, int level, int optname, void *optval,
size_t *optlen`ptr)
`sys/socket.h' (BSD): Раздел 11.11.1 [Функции Опций Гнезда].
int gettimeofday (struct timeval *tp, struct timezone *tzp)
`sys/time.h' (BSD): Раздел 17.2.2 [Точный Календарь].
uid_t getuid (void)
`unistd.h' (POSIX.1): Раздел 25.5 [Чтение Persona].
mode_t getumask (void)
`sys/stat.h' (GNU): Раздел 9.8.7 [Установка Прав].
char * getwd (char *buffer)
`unistd.h' (BSD): Раздел 9.1 [Рабочий Каталог].
int getw (FILE *stream)
`stdio.h' (SVID): Раздел 7.6 [Символьный Ввод].
gid_t
`sys/types.h' (POSIX.1): Раздел 25.5 [Чтение Persona].
GLOB_ABORTED
`glob.h' (POSIX.2): Раздел 16.2.1 [Вызов Glob].
GLOB_APPEND
`glob.h' (POSIX.2): Раздел 16.2.2 [Флаги для Globbing].
GLOB_DOOFFS
`glob.h' (POSIX.2): Раздел 16.2.2 [Флаги для Globbing].
GLOB_ERR
`glob.h' (POSIX.2): Раздел 16.2.2 [Флаги для Globbing].
int glob (const char *pattern, int flags, int (*errfunc)
(const char *filename, int error-code), glob_t *vector`ptr)
`glob.h' (POSIX.2): Раздел 16.2.1 [Вызов Glob].
GLOB_MARK
`glob.h' (POSIX.2): Раздел 16.2.2 [Флаги для Globbing].
GLOB_NOCHECK
`glob.h' (POSIX.2): Раздел 16.2.2 [Флаги для Globbing].
GLOB_NOESCAPE
`glob.h' (POSIX.2): Раздел 16.2.2 [Флаги для Globbing].
GLOB_NOMATCH
`glob.h' (POSIX.2): Раздел 16.2.1 [Вызов Glob].
GLOB_NOSORT
`glob.h' (POSIX.2): Раздел 16.2.2 [Флаги для Globbing].
GLOB_NOSPACE
`glob.h' (POSIX.2): Раздел 16.2.1 [Вызов Glob].
glob_t
`glob.h' (POSIX.2): Раздел 16.2.1 [Вызов Glob].
struct tm * gmtime (const time_t *time)
`time.h' (ANSI): Раздел 17.2.3 [Сброшенное Время].
_GNU_SOURCE
(GNU): Раздел 1.3.4 [Макрокоманды Возможностей].
int gsignal (int signum)
`signal.h' (SVID): Раздел 21.6.1 [Сигналы Самому Себе].
HOST_NOT_FOUND
`netdb.h' (BSD): Раздел 11.5.2.4 [Главные Имена].
unsigned long int htonl (unsigned long int hostlong)
`netinet/in.h' (BSD): Раздел 11.5.5 [Байтовый Порядок].
unsigned short int htons (unsigned short int hostshort)
`netinet/in.h' (BSD): Раздел 11.5.5 [Байтовый Порядок].
double HUGE_VAL
`math.h' (ANSI): Раздел 13.1 [Ошибки Области и Диапазона].
HUPCL
`termios.h' (POSIX.1): Раздел 12.4.6 [Контрольные Режимы].
double hypot (double x, double y)
`math.h' (BSD): Раздел 13.4 [Экспоненты и Логарифмы].
ICANON
`termios.h' (POSIX.1): Раздел 12.4.7 [Автономные режимы].
ICRNL
`termios.h' (POSIX.1): Раздел 12.4.4 [Режимы Ввода].
IEXTEN
`termios.h' (POSIX.1): Раздел 12.4.7 [Автономные режимы].
IGNBRK
`termios.h' (POSIX.1): Раздел 12.4.4 [Режимы Ввода].
IGNCR
`termios.h' (POSIX.1): Раздел 12.4.4 [Режимы Ввода].
IGNPAR
`termios.h' (POSIX.1): Раздел 12.4.4 [Режимы Ввода].
IMAXBEL
`termios.h' (BSD): Раздел 12.4.4 [Режимы Ввода].
unsigned long int INADDR_ANY
`netinet/in.h' (BSD): Раздел 11.5.2.2 [Главный Адрес (тип_данных)].
unsigned long int INADDR_BROADCAST
`netinet/in.h' (BSD): Раздел 11.5.2.2 [Главный Адрес (тип_данных)].
unsigned long int INADDR_LOOPBACK
`netinet/in.h' (BSD): Раздел 11.5.2.2 [Главный Адрес (тип_данных)].
unsigned long int INADDR_NONE
`netinet/in.h' (BSD): Раздел 11.5.2.2 [Главный Адрес (тип_данных)].
char * index (const char *string, int c)
`string.h' (BSD): Раздел 5.7 [Функции Поиска].
unsigned long int inet_addr (const char *name)
`arpa/inet.h' (BSD): Раздел 11.5.2.3 [Фукции Главного Адреса].
int inet_aton (const char *name, struct in_addr *addr)
`arpa/inet.h' (BSD): Раздел 11.5.2.3 [Фукции Главного Адреса].
int inet_lnaof (struct in_addr addr)
`arpa/inet.h' (BSD): Раздел 11.5.2.3 [Фукции Главного Адреса].
struct in_addr inet_makeaddr (int net, int local)
`arpa/inet.h' (BSD): Раздел 11.5.2.3 [Фукции Главного Адреса].
int inet_netof (struct in_addr addr)
`arpa/inet.h' (BSD): Раздел 11.5.2.3 [Фукции Главного Адреса].
unsigned long int inet_network (const char *name)
`arpa/inet.h' (BSD): Раздел 11.5.2.3 [Фукции Главного Адреса].
char * inet_ntoa (struct in_addr addr)
`arpa/inet.h' (BSD): Раздел 11.5.2.3 [Фукции Главного Адреса].
double infnan (int error)
`math.h' (BSD): Раздел 14.2 [Предикаты на Float].
int initgroups (const char *user, gid_t gid)
`grp.h' (BSD): Раздел 25.7 [Установка Группы].
void * initstate (unsigned int seed, void *state, size_t size)
`stdlib.h' (BSD): Раздел 13.6.2 [BSD Random].
INLCR
`termios.h' (POSIX.1): Раздел 12.4.4 [Режимы Ввода].
ino_t
`sys/types.h' (POSIX.1): Раздел 9.8.1 [Значения Атрибутов].
INPCK
`termios.h' (POSIX.1): Раздел 12.4.4 [Режимы Ввода].
int RLIM_INFINITY
`sys/resource.h' (BSD): Раздел 17.6 [Ограничения Ресурсов].
INT_MAX
`limits.h' (ANSI): Раздел A.5.2 [Диапазон Типа].
INT_MIN
`limits.h' (ANSI): Раздел A.5.2 [Диапазон Типа].
int _IOFBF
`stdio.h' (ANSI): Раздел 7.17.3 [Буферизация Управления].
int _IOLBF
`stdio.h' (ANSI): Раздел 7.17.3 [Буферизация Управления].
int _IONBF
`stdio.h' (ANSI): Раздел 7.17.3 [Буферизация Управления].
int IPPORT_RESERVED
`netinet/in.h' (BSD): Раздел 11.5.3 [Порты].
int IPPORT_USERRESERVED
`netinet/in.h' (BSD): Раздел 11.5.3 [Порты].
int isalnum (int c)
`ctype.h' (ANSI): Раздел 4.1 [Классификация Символов].
int isalpha (int c)
`ctype.h' (ANSI): Раздел 4.1 [Классификация Символов].
int isascii (int c)
`ctype.h' (SVID, BSD): Раздел 4.1 [Классификация Символов].
int isatty (int filedes)
`unistd.h' (POSIX.1): Раздел 12.1 [Терминал ли это].
int isblank (int c)
`ctype.h' (GNU): Раздел 4.1 [Классификация Символов].
int iscntrl (int c)
`ctype.h' (ANSI): Раздел 4.1 [Классификация Символов].
int isdigit (int c)
`ctype.h' (ANSI): Раздел 4.1 [Классификация Символов].
int isgraph (int c)
`ctype.h' (ANSI): Раздел 4.1 [Классификация Символов].
ISIG
`termios.h' (POSIX.1): Раздел 12.4.7 [Автономные режимы].
int isinf (double x)
`math.h' (BSD): Раздел 14.2 [Предикаты на Float].
int islower (int c)
`ctype.h' (ANSI): Раздел 4.1 [Классификация Символов].
int isnan (double x)
`math.h' (BSD): Раздел 14.2 [Предикаты на Float].
int isprint (int c)
`ctype.h' (ANSI): Раздел 4.1 [Классификация Символов].
int ispunct (int c)
`ctype.h' (ANSI): Раздел 4.1 [Классификация Символов].
int isspace (int c)
`ctype.h' (ANSI): Раздел 4.1 [Классификация Символов].
ISTRIP
`termios.h' (POSIX.1): Раздел 12.4.4 [Режимы Ввода].
int isupper (int c)
`ctype.h' (ANSI): Раздел 4.1 [Классификация Символов].
int isxdigit (int c)
`ctype.h' (ANSI): Раздел 4.1 [Классификация Символов].
char * tzname [2]
`time.h' (POSIX.1): Раздел 17.2.6 [Функции для Временной Зоны].
ITIMER_PROF
`sys/time.h' (BSD): Раздел 17.3 [Установка Сигнализации].
ITIMER_REAL
`sys/time.h' (BSD): Раздел 17.3 [Установка Сигнализации].
ITIMER_VIRTUAL
`sys/time.h' (BSD): Раздел 17.3 [Установка Сигнализации].
IXANY
`termios.h' (BSD): Раздел 12.4.4 [Режимы Ввода].
IXOFF
`termios.h' (POSIX.1): Раздел 12.4.4 [Режимы Ввода].
IXON
`termios.h' (POSIX.1): Раздел 12.4.4 [Режимы Ввода].
jmp_buf
`setjmp.h' (ANSI): Раздел 20.2 [Не-локальные Подробности].
int kill (pid_t pid, int signum)
`signal.h' (POSIX.1): Раздел 21.6.2 [Сигналы Дугому Процессу].
int killpg (int pgid, int signum)
`signal.h' (BSD): Раздел 21.6.2 [Сигналы Дугому Процессу].
long int labs (long int number)
`stdlib.h' (ANSI): Раздел 14.3 [Абсолютное Значение].
LANG
`locale.h' (ANSI): Раздел 19.3 [Категории Стандарта].
LC_ALL
`locale.h' (ANSI): Раздел 19.3 [Категории Стандарта].
LC_COLLATE
`locale.h' (ANSI): Раздел 19.3 [Категории Стандарта].
LC_CTYPE
`locale.h' (ANSI): Раздел 19.3 [Категории Стандарта].
LC_MONETARY
`locale.h' (ANSI): Раздел 19.3 [Категории Стандарта].
LC_NUMERIC
`locale.h' (ANSI): Раздел 19.3 [Категории Стандарта].
LC_RESPONSE
`locale.h' (GNU): Раздел 19.3 [Категории Стандарта].
int L_ctermid
`stdio.h' (POSIX.1): Раздел 24.7.1 [Идентификация Терминала].
LC_TIME
`locale.h' (ANSI): Раздел 19.3 [Категории Стандарта].
int L_cuserid
`stdio.h' (POSIX.1): Раздел 25.11 [Кто вошел в систему].
double ldexp (double value, int exponent)
`math.h' (ANSI): Раздел 14.4 [Функции Нормализации].
ldiv_t ldiv (long int numerator, long int denominator)
`stdlib.h' (ANSI): Раздел 14.6 [Целое Деление].
ldiv_t
`stdlib.h' (ANSI): Раздел 14.6 [Целое Деление].
L_INCR
`sys/file.h' (BSD): Раздел 7.15 [Позиционирование Файла].
int LINE_MAX
`limits.h' (POSIX.2): Раздел 27.10 [Пределы Утилит].
int link (const char *oldname, const char *newname)
`unistd.h' (POSIX.1): Раздел 9.3 [Жесткие Связи].
int LINK_MAX
`limits.h' (POSIX.1): Раздел 27.6 [Ограничения для Файлов].
int listen (int socket, unsigned int n)
`sys/socket.h' (BSD): Раздел 11.8.2 [Ожидание].
struct lconv * localeconv (void)
`locale.h' (ANSI): Раздел 19.6 [Форматирование Чисел].
struct tm * localtime (const time_t *time)
`time.h' (ANSI): Раздел 17.2.3 [Сброшенное Время].
double log10 (double x)
`math.h' (ANSI): Раздел 13.4 [Экспоненты и Логарифмы].
double log1p (double x)
`math.h' (BSD): Раздел 13.4 [Экспоненты и Логарифмы].
double logb (double x)
`math.h' (BSD): Раздел 14.4 [Функции Нормализации].
double log (double x)
`math.h' (ANSI): Раздел 13.4 [Экспоненты и Логарифмы].
void longjmp (jmp_buf state, int value)
`setjmp.h' (ANSI): Раздел 20.2 [Не-локальные Подробности].
LONG_LONG_MAX
`limits.h' (GNU): Раздел A.5.2 [Диапазон Типа].
LONG_LONG_MIN
`limits.h' (GNU): Раздел A.5.2 [Диапазон Типа].
LONG_MAX
`limits.h' (ANSI): Раздел A.5.2 [Диапазон Типа].
LONG_MIN
`limits.h' (ANSI): Раздел A.5.2 [Диапазон Типа].
off_t lseek (int filedes, off_t offset, int whence)
`unistd.h' (POSIX.1): Раздел 8.3 [Примитивы Файловой позиции].
L_SET
`sys/file.h' (BSD): Раздел 7.15 [Позиционирование Файла].
int lstat (const char *filename, struct stat *buf )
`sys/stat.h' (BSD): Раздел 9.8.2 [Чтение Атрибутов].
int L_tmpnam
`stdio.h' (ANSI): Раздел 9.10 [Временные Файлы].
L_XTND
`sys/file.h' (BSD): Раздел 7.15 [Позиционирование Файла].
__malloc_hook
`malloc.h' (GNU): Раздел 3.3.9 [Ловушки для Malloc].
void * malloc (size_t size)
`malloc.h', `stdlib.h' (ANSI): Раздел 3.3.1 [Основное Распределние].
int MAX_CANON
`limits.h' (POSIX.1): Раздел 27.6 [Ограничения для Файлов].
int MAX_INPUT
`limits.h' (POSIX.1): Раздел 27.6 [Ограничения для Файлов].
int MAXNAMLEN
`dirent.h' (BSD): Раздел 27.6 [Ограничения для Файлов].
int MB_CUR_MAX
`stdlib.h' (ANSI): Раздел 18.3 [Введение Многобайтовых Символов].
int mblen (const char *string, size_t size)
`stdlib.h' (ANSI): Раздел 18.6 [Длина Символа].
int MB_LEN_MAX
`limits.h' (ANSI): Раздел 18.3 [Введение Многобайтовых Символов].
size_t mbstowcs (wchar_t *wstring, const char *string, size_t size)
`stdlib.h' (ANSI): Раздел 18.5 [Расширенное Строковое Преобразование].
int mbtowc (wchar_t *result, const char *string, size_t size)
`stdlib.h' (ANSI): Раздел 18.7 [Преобразование Одного Символа].
int mcheck (void (*abortfn) (void))
`malloc.h' (GNU): Раздел 3.3.8 [Проверка Непротиворечивости "Кучи "].
MDMBUF
`termios.h' (BSD): Раздел 12.4.6 [Контрольные Режимы].
void * memalign (size_t size, size_t boundary)
`malloc.h', `stdlib.h' (BSD): Раздел 3.3.7 [Выравниваемые Блоки Памяти].
void * memccpy (void *to, const void *from, int c, size_t size)
`string.h' (SVID): Раздел 5.4 [Копирование и Конкатенация].
void * memchr (const void *block, int c, size_t size)
`string.h' (ANSI): Раздел 5.7 [Функции Поиска].
int memcmp (const void *a1, const void *a2, size_t size)
`string.h' (ANSI): Раздел 5.5 [Сравнение Строки/Массива].
void * memcpy (void *to, const void *from, size_t size)
`string.h' (ANSI): Раздел 5.4 [Копирование и Конкатенация].
void * memmem (const void *needle, size_t needle`len,
const void *haystack, size_t haystack`len)
`string.h' (GNU): Раздел 5.7 [Функции Поиска].
void * memmove (void *to, const void *from, size_t size)
`string.h' (ANSI): Раздел 5.4 [Копирование и Конкатенация].
void memory_warnings (void *start, void (*warn`func) (const char *))
`malloc.h' (GNU): Раздел 3.7 [Предупреждения Использования Памяти].
void * memset (void *block, int c, size_t size)
`string.h' (ANSI): Раздел 5.4 [Копирование и Конкатенация].
int mkdir (const char *filename, mode_t mode)
`sys/stat.h' (POSIX.1): Раздел 9.7 [Создание Каталогов].
int mkfifo (const char *filename, mode_t mode)
`sys/stat.h' (POSIX.1): Раздел 10.3 [Специальные FIFO Файлы].
int mknod (const char *filename, int mode, int dev)
`sys/stat.h' (BSD): Раздел 9.9 [Создание Специальных Файлов].
int mkstemp (char *template)
`unistd.h' (BSD): Раздел 9.10 [Временные Файлы].
char * mktemp (char *template)
`unistd.h' (Unix): Раздел 9.10 [Временные Файлы].
time_t mktime (struct tm *brokentime)
`time.h' (ANSI): Раздел 17.2.3 [Сброшенное Время].
mode_t
`sys/types.h' (POSIX.1): Раздел 9.8.1 [Значения Атрибутов].
double modf (double value, double *integer`part)
`math.h' (ANSI): Раздел 14.5 [Округление и Остаточные члены].
int MSG_DONTROUTE
`sys/socket.h' (BSD): Раздел 11.8.5.3 [Опции Данных Гнезда].
int MSG_OOB
`sys/socket.h' (BSD): Раздел 11.8.5.3 [Опции Данных Гнезда].
int MSG_PEEK
`sys/socket.h' (BSD): Раздел 11.8.5.3 [Опции Данных Гнезда].
struct mstats mstats (void)
`malloc.h' (GNU): Раздел 3.3.10 [Статистика Malloc].
int NAME_MAX
`limits.h' (POSIX.1): Раздел 27.6 [Ограничения для Файлов].
double NAN
`math.h' (GNU): Раздел 14.1 [Не число (Not a Number, NaN)].
int NCCS
`termios.h' (POSIX.1): Раздел 12.4.1 [Тип Данных Режима].
int NGROUPS_MAX
`limits.h' (POSIX.1): Раздел 27.1 [Основные Ограничения].
int nice (int increment)
`dunno.h' (dunno.h): Раздел 17.7 [Приоритет].
nlink_t
`sys/types.h' (POSIX.1): Раздел 9.8.1 [Значения Атрибутов].
NO_ADDRESS
`netdb.h' (BSD): Раздел 11.5.2.4 [Главные Имена].
NOFLSH
`termios.h' (POSIX.1): Раздел 12.4.7 [Автономные режимы].
NOKERNINFO
`termios.h' (BSD): Раздел 12.4.7 [Автономные режимы].
NO_RECOVERY
`netdb.h' (BSD): Раздел 11.5.2.4 [Главные Имена].
int NSIG
`signal.h' (BSD): Раздел 21.2 [Стандартные Сигналы].
unsigned long int ntohl (unsigned long int netlong)
`netinet/in.h' (BSD): Раздел 11.5.5 [Байтовый Порядок].
unsigned short int ntohs (unsigned short int netshort)
`netinet/in.h' (BSD): Раздел 11.5.5 [Байтовый Порядок].
void * NULL
`stddef.h' (ANSI): Раздел A.3 [Константа - Нулевой Указатель].
int O_ACCMODE
`fcntl.h' (POSIX.1): Раздел 8.10 [Флаги Состояния Файла].
O_APPEND
`fcntl.h' (POSIX.1): Раздел 8.10 [Флаги Состояния Файла].
O_APPEND
`fcntl.h' (POSIX.1): Раздел 8.1 [Открытие и Закрытие Файлов].
void obstack_1grow_fast (struct obstack *obstack`ptr, char c)
`obstack.h' (GNU): Раздел 3.4.7 [Сверх Быстрый Рост].
void obstack_1grow (struct obstack *obstack`ptr, char c)
`obstack.h' (GNU): Раздел 3.4.6 [Возрастающие Объекты].
int obstack_alignment_mask (struct obstack *obstack`ptr)
`obstack.h' (GNU): Раздел 3.4.9 [Obstacks Выравнивание Данных].
void * obstack_alloc (struct obstack *obstack`ptr, size_t size)
`obstack.h' (GNU): Раздел 3.4.3 [Резервирование в Obstack].
void * obstack_base (struct obstack *obstack`ptr)
`obstack.h' (GNU): Раздел 3.4.8 [Состофние Obstack].
void obstack_blank_fast (struct obstack *obstack`ptr, size_t size)
`obstack.h' (GNU): Раздел 3.4.7 [Сверх Быстрый Рост].
void obstack_blank (struct obstack *obstack`ptr, size_t size)
`obstack.h' (GNU): Раздел 3.4.6 [Возрастающие Объекты].
size_t obstack_chunk_size (struct obstack *obstack`ptr)
`obstack.h' (GNU): Раздел 3.4.10 [Куски в Obstack].
void * obstack_copy0 (struct obstack *obstack`ptr, void *address,
size_t size)
`obstack.h' (GNU): Раздел 3.4.3 [Резервирование в Obstack].
void * obstack_copy (struct obstack *obstack`ptr, void *address,
size_t size)
`obstack.h' (GNU): Раздел 3.4.3 [Резервирование в Obstack].
void * obstack_finish (struct obstack *obstack`ptr)
`obstack.h' (GNU): Раздел 3.4.6 [Возрастающие Объекты].
void obstack_free (struct obstack *obstack`ptr, void *object)
`obstack.h' (GNU): Раздел 3.4.4 [Освобождение Obstack Объектов].
void obstack_grow0 (struct obstack *obstack`ptr, void *data,
size_t size)
`obstack.h' (GNU): Раздел 3.4.6 [Возрастающие Объекты].
void obstack_grow (struct obstack *obstack`ptr, void *data, size_t size)
`obstack.h' (GNU): Раздел 3.4.6 [Возрастающие Объекты].
void obstack_init (struct obstack *obstack`ptr)
`obstack.h' (GNU): Раздел 3.4.2 [Подготовка к Использованию Obstack].
void * obstack_next_free (struct obstack *obstack`ptr)
`obstack.h' (GNU): Раздел 3.4.8 [Состояние Obstack].
size_t obstack_object_size (struct obstack *obstack`ptr)
`obstack.h' (GNU): Раздел 3.4.6 [Возрастающие Объекты].
size_t obstack_object_size (struct obstack *obstack`ptr)
`obstack.h' (GNU): Раздел 3.4.8 [Состояние Obstack].
int obstack_printf (struct obstack *obstack, const char *template,. . .)
`stdio.h' (GNU): Раздел 7.9.8 [Динамический Вывод].
size_t obstack_room (struct obstack *obstack`ptr)
`obstack.h' (GNU): Раздел 3.4.7 [Сверх Быстрый Рост].
int obstack_vprintf (struct obstack *obstack, const char *template,
va_list ap)
`stdio.h' (GNU): Раздел 7.9.9 [Вывод с Переменными Аргументами].
O_CREAT
`fcntl.h' (POSIX.1): Раздел 8.1 [Открытие и Закрытие Файлов].
O_EXCL
`fcntl.h' (POSIX.1): Раздел 8.1 [Открытие и Закрытие Файлов].
size_t offsetof (type, member)
`stddef.h' (ANSI): Раздел A.5.4 [Размер Структуры].
off_t
`sys/types.h' (POSIX.1): Раздел 8.3 [Примитивы Файловой позиции].
O_NDELAY
`fcntl.h' (BSD): Раздел 8.10 [Флаги Состояния Файла].
int on_exit (void (*function)(int status, void *arg), void *arg)
`stdlib.h' (SunOS): Раздел 22.3.3 [Оистки на Выходе].
int ONLCR
`termios.h' (BSD): Раздел 12.4.5 [Режимы Вывода].
O_NOCTTY
`fcntl.h' (POSIX.1): Раздел 8.1 [Открытие и Закрытие Файлов].
int ONOEOT
`termios.h' (BSD): Раздел 12.4.5 [Режимы Вывода].
O_NONBLOCK
`fcntl.h' (POSIX.1): Раздел 8.10 [Флаги Состояния Файла].
O_NONBLOCK
`fcntl.h' (POSIX.1): Раздел 8.1 [Открытие и Закрытие Файлов].
DIR * opendir (const char *dirname)
`dirent.h' (POSIX.1): Раздел 9.2.2 [Открытие Каталога].
int open (const char *filename, int flags[, mode_t mode])
`fcntl.h' (POSIX.1): Раздел 8.1 [Открытие и Закрытие Файлов].
int OPEN_MAX
`limits.h' (POSIX.1): Раздел 27.1 [Основные Ограничения].
FILE * open_memstream (char **ptr, size_t *sizeloc)
`stdio.h' (GNU): Раздел 7.18.1 [Строковые Потоки].
FILE * open_obstack_stream (struct obstack *obstack)
`stdio.h' (GNU): Раздел 7.18.2 [Obstack Потоки].
int OPOST
`termios.h' (POSIX.1): Раздел 12.4.5 [Режимы Вывода].
char * optarg
`unistd.h' (POSIX.2): Раздел 22.1.2 [Синтаксический анализ Опций].
int opterr
`unistd.h' (POSIX.2): Раздел 22.1.2 [Синтаксический анализ Опций].
int optind
`unistd.h' (POSIX.2): Раздел 22.1.2 [Синтаксический анализ Опций].
int optopt
`unistd.h' (POSIX.2): Раздел 22.1.2 [Синтаксический анализ Опций].
O_RDONLY
`fcntl.h' (POSIX.1): Раздел 8.1 [Открытие и Закрытие Файлов].
O_RDWR
`fcntl.h' (POSIX.1): Раздел 8.1 [Открытие и Закрытие Файлов].
O_TRUNC
`fcntl.h' (POSIX.1): Раздел 8.1 [Открытие и Закрытие Файлов].
O_WRONLY
`fcntl.h' (POSIX.1): Раздел 8.1 [Открытие и Закрытие Файлов].
int OXTABS
`termios.h' (BSD): Раздел 12.4.5 [Режимы Вывода].
PA_CHAR
`printf.h' (GNU): Раздел 7.9.10 [Синтаксический анализ Строки Шаблона].
PA_DOUBLE
`printf.h' (GNU): Раздел 7.9.10 [Синтаксический анализ Строки Шаблона].
PA_FLAG_LONG_DOUBLE
`printf.h' (GNU): Раздел 7.9.10 [Синтаксический анализ Строки Шаблона].
PA_FLAG_LONG
`printf.h' (GNU): Раздел 7.9.10 [Синтаксический анализ Строки Шаблона].
PA_FLAG_LONG_LONG
`printf.h' (GNU): Раздел 7.9.10 [Синтаксический анализ Строки Шаблона].
int PA_FLAG_MASK
`printf.h' (GNU): Раздел 7.9.10 [Синтаксический анализ Строки Шаблона].
PA_FLAG_PTR
`printf.h' (GNU): Раздел 7.9.10 [Синтаксический анализ Строки Шаблона].
PA_FLAG_SHORT
`printf.h' (GNU): Раздел 7.9.10 [Синтаксический анализ Строки Шаблона].
PA_FLOAT
`printf.h' (GNU): Раздел 7.9.10 [Синтаксический анализ Строки Шаблона].
PA_INT
`printf.h' (GNU): Раздел 7.9.10 [Синтаксический анализ Строки Шаблона].
PA_LAST
`printf.h' (GNU): Раздел 7.9.10 [Синтаксический анализ Строки Шаблона].
PA_POINTER
`printf.h' (GNU): Раздел 7.9.10 [Синтаксический анализ Строки Шаблона].
PARENB
`termios.h' (POSIX.1): Раздел 12.4.6 [Контрольные Режимы].
PARMRK
`termios.h' (POSIX.1): Раздел 12.4.4 [Режимы Ввода].
PARODD
`termios.h' (POSIX.1): Раздел 12.4.6 [Контрольные Режимы].
size_t parse_printf_format (const char *template, size_t n,
int *argtypes)
`printf.h' (GNU): Раздел 7.9.10 [Синтаксический анализ Строки Шаблона].
PA_STRING
`printf.h' (GNU): Раздел 7.9.10 [Синтаксический анализ Строки Шаблона].
long int pathconf (const char *filename, int parameter)
`unistd.h' (POSIX.1): Раздел 27.9 [Pathconf].
int PATH_MAX
`limits.h' (POSIX.1): Раздел 27.6 [Ограничения для Файлов].
int pause ()
`unistd.h' (POSIX.1): Раздел 21.8.1 [Использование Pause].
_PC_CHOWN_RESTRICTED
`unistd.h' (POSIX.1): Раздел 27.9 [Pathconf].
_PC_LINK_MAX
`unistd.h' (POSIX.1): Раздел 27.9 [Pathconf].
int pclose (FILE *stream)
`stdio.h' (POSIX.2, SVID, BSD): Раздел 10.2 [Трубопрвод в Подпроцесс].
_PC_MAX_CANON
`unistd.h' (POSIX.1): Раздел 27.9 [Pathconf].
_PC_MAX_INPUT
`unistd.h' (POSIX.1): Раздел 27.9 [Pathconf].
_PC_NAME_MAX
`unistd.h' (POSIX.1): Раздел 27.9 [Pathconf].
_PC_NO_TRUNC
`unistd.h' (POSIX.1): Раздел 27.9 [Pathconf].
_PC_PATH_MAX
`unistd.h' (POSIX.1): Раздел 27.9 [Pathconf].
_PC_PIPE_BUF
`unistd.h' (POSIX.1): Раздел 27.9 [Pathconf].
_PC_VDISABLE
`unistd.h' (POSIX.1): Раздел 27.9 [Pathconf].
PENDIN
`termios.h' (BSD): Раздел 12.4.7 [Автономные режимы].
void perror (const char *message)
`stdio.h' (ANSI): Раздел 2.3 [Сообщения об Ошибках].
int PF_FILE
`sys/socket.h' (GNU): Раздел 11.4.2 [Подробности Имени Файла].
int PF_INET
`sys/socket.h' (BSD): Раздел 11.5 [Именное Пространство Internet]
int PF_UNIX
`sys/socket.h' (BSD): Раздел 11.4.2 [Подробности Имени Файла].
pid_t
`sys/types.h' (POSIX.1): Раздел 23.3 [Идентификация Процесса].
int PIPE_BUF
`limits.h' (POSIX.1): Раздел 27.6 [Ограничения для Файлов].
int pipe (int filedes[2])
`unistd.h' (POSIX.1): Раздел 10.1 [Создание Трубопровода].
FILE * popen (const char *command, const char *mode)
`stdio.h' (POSIX.2, SVID, BSD): Раздел 10.2 [Трубопрвод в Подпроцесс].
_POSIX2_BC_BASE_MAX
`limits.h' (POSIX.2): Раздел 27.11 [Минимумы Утилит].
_POSIX2_BC_DIM_MAX
`limits.h' (POSIX.2): Раздел 27.11 [Минимумы Утилит].
_POSIX2_BC_SCALE_MAX
`limits.h' (POSIX.2): Раздел 27.11 [Минимумы Утилит].
_POSIX2_BC_STRING_MAX
`limits.h' (POSIX.2): Раздел 27.11 [Минимумы Утилит].
int _POSIX2_C_DEV
`unistd.h' (POSIX.2): Раздел 27.2 [Опции Системы].
_POSIX2_COLL_WEIGHTS_MAX
`limits.h' (POSIX.2): Раздел 27.11 [Минимумы Утилит].
long int _POSIX2_C_VERSION
`unistd.h' (POSIX.2): Раздел 27.3 [Обеспечиваемая Версия].
_POSIX2_EQUIV_CLASS_MAX
`limits.h' (POSIX.2): Раздел 27.11 [Минимумы Утилит].
_POSIX2_EXPR_NEST_MAX
`limits.h' (POSIX.2): Раздел 27.11 [Минимумы Утилит].
int _POSIX2_FORT_DEV
`unistd.h' (POSIX.2): Раздел 27.2 [Опции Системы].
int _POSIX2_FORT_RUN
`unistd.h' (POSIX.2): Раздел 27.2 [Опции Системы].
_POSIX2_LINE_MAX
`limits.h' (POSIX.2): Раздел 27.11 [Минимумы Утилит].
int _POSIX2_LOCALEDEF
`unistd.h' (POSIX.2): Раздел 27.2 [Опции Системы Утилит].
_POSIX2_RE_DUP_MAX
`limits.h' (POSIX.2): Раздел 27.5 [Минимумы].
int _POSIX2_SW_DEV
`unistd.h' (POSIX.2): Раздел 27.2 [Опции Системы].
_POSIX_ARG_MAX
`limits.h' (POSIX.1): Раздел 27.5 [Минимумы].
_POSIX_CHILD_MAX
`limits.h' (POSIX.1): Раздел 27.5 [Минимумы].
int _POSIX_CHOWN_RESTRICTED
`unistd.h' (POSIX.1): Раздел 27.7 [Опции для Файлов].
_POSIX_C_SOURCE
(POSIX.2): Раздел 1.3.4 [Макрокоманды Возможностей].
int _POSIX_JOB_CONTROL
`unistd.h' (POSIX.1): Раздел 27.2 [Опции Системы].
_POSIX_LINK_MAX
`limits.h' (POSIX.1): Раздел 27.8 [Минимумы для Файлов].
_POSIX_MAX_CANON
`limits.h' (POSIX.1): Раздел 27.8 [Минимумы для Файлов].
_POSIX_MAX_INPUT
`limits.h' (POSIX.1): Раздел 27.8 [Минимумы для Файлов].
_POSIX_NAME_MAX
`limits.h' (POSIX.1): Раздел 27.8 [Минимумы для Файлов].
_POSIX_NGROUPS_MAX
`limits.h' (POSIX.1): Раздел 27.5 [Минимумы].
int _POSIX_NO_TRUNC
`unistd.h' (POSIX.1): Раздел 27.7 [Опции для Файлов].
_POSIX_OPEN_MAX
`limits.h' (POSIX.1): Раздел 27.5 [Минимумы].
_POSIX_PATH_MAX
`limits.h' (POSIX.1): Раздел 27.8 [Минимумы для Файлов].
_POSIX_PIPE_BUF
`limits.h' (POSIX.1): Раздел 27.8 [Минимумы для Файлов].
int _POSIX_SAVED_IDS
`unistd.h' (POSIX.1): Раздел 27.2 [Опции Системы].
_POSIX_SOURCE
(POSIX.1): Раздел 1.3.4 [Макрокоманды Возможностей].
_POSIX_SSIZE_MAX
`limits.h' (POSIX.1): Раздел 27.5 [Минимумы].
_POSIX_STREAM_MAX
`limits.h' (POSIX.1): Раздел 27.5 [Минимумы].
_POSIX_TZNAME_MAX
`limits.h' (POSIX.1): Раздел 27.5 [Минимумы].
unsigned char _POSIX_VDISABLE
`unistd.h' (POSIX.1): Раздел 27.7 [Опции для Файлов].
long int _POSIX_VERSION
`unistd.h' (POSIX.1): Раздел 27.3 [Обеспечиваемая Версия].
double pow (double base, double power)
`math.h' (ANSI): Раздел 13.4 [Экспоненты и Логарифмы].
printf_arginfo_function
`printf.h' (GNU): Раздел 7.10.3 [Определение Обработчика Вывода].
printf_function
`printf.h' (GNU): Раздел 7.10.3 [Определение Обработчика Вывода].
int printf (const char *template, . . .)
`stdio.h' (ANSI): Раздел 7.9.7 [Функции Форматированного Вывода].
PRIO_MAX
`sys/resource.h' (BSD): Раздел 17.7 [Приоритет].
PRIO_MIN
`sys/resource.h' (BSD): Раздел 17.7 [Приоритет].
PRIO_PGRP
`sys/resource.h' (BSD): Раздел 17.7 [Приоритет].
PRIO_PROCESS
`sys/resource.h' (BSD): Раздел 17.7 [Приоритет].
PRIO_USER
`sys/resource.h' (BSD): Раздел 17.7 [Приоритет].
char * program_invocation_name
`errno.h' (GNU): Раздел 2.3 [Сообщения об Ошибках].
char * program_invocation_short_name
`errno.h' (GNU): Раздел 2.3 [Сообщения об Ошибках].
void psignal (int signum, const char *message)
`stdio.h' (BSD): Раздел 21.2.8 [Сообщения Сигналов].
char * P_tmpdir
`stdio.h' (SVID): Раздел 9.10 [Временные Файлы].
ptrdiff_t
`stddef.h' (ANSI): Раздел A.4 [Важные Типы Данных].
int putchar (int c)
`stdio.h' (ANSI): Раздел 7.5 [Простой Вывод].
int putc (int c, FILE *stream)
`stdio.h' (ANSI): Раздел 7.5 [Простой Вывод].
int putenv (const char *string)
`stdlib.h' (SVID): Раздел 22.2.1 [Доступ Среды].
int putpwent (const struct passwd *p, FILE *stream)
`pwd.h' (SVID): Раздел 25.12.4 [Написание Входа Пользователя].
int puts (const char *s)
`stdio.h' (ANSI): Раздел 7.5 [Простой Вывод].
int putw (int w, FILE *stream)
`stdio.h' (SVID): Раздел 7.5 [Простой Вывод].
void qsort (void *array, size_t count, size_t size,
comparison_fn_t compare)
`stdlib.h' (ANSI): Раздел 15.3 [Функции Сортировки Массива].
int raise (int signum)
`signal.h' (ANSI): Раздел 21.6.1 [Сигналы Самому Себе].
void r_alloc_free (void **handleptr)
`malloc.h' (GNU): Раздел 3.6.2 [Распределение Переместимых Блоков].
void * r_alloc (void **handleptr, size_t size)
`malloc.h' (GNU): Раздел 3.6.2 [Распределение Переместимых Блоков].
int rand ()
`stdlib.h' (ANSI): Раздел 13.6.1 [ANSI Random].
int RAND_MAX
`stdlib.h' (ANSI): Раздел 13.6.1 [ANSI Random].
long int random ()
`stdlib.h' (BSD): Раздел 13.6.2 [BSD Random].
struct dirent * readdir (DIR *dirstream)
`dirent.h' (POSIX.1): Раздел 9.2.3 [Чтение/Закрытие Каталога].
ssize_t read (int filedes, void *buffer, size_t size)
`unistd.h' (POSIX.1): Раздел 8.2 [Прмитивы Ввода/Вывода].
int readlink (const char *filename, char *buffer, size_t size)
`unistd.h' (BSD): Раздел 9.4 [Символические Связи].
__realloc_hook
`malloc.h' (GNU): Раздел 3.3.9 [Ловушки для Malloc].
void * realloc (void *ptr, size_t newsize)
`malloc.h', `stdlib.h' (ANSI): Раздел 3.3.4 [Изменение Размера Блока].
int recvfrom (int socket, void *buffer, size_t size, int flags,
struct sockaddr *addr, size_t *length`ptr)
`sys/socket.h' (BSD): Раздел 11.9.2 [Получение Датаграмм].
int recv (int socket, void *buffer, size_t size, int flags)
`sys/socket.h' (BSD): Раздел 11.8.5.2 [Получение Данных].
int recvmsg (int socket, struct msghdr *message, int flags)
`sys/socket.h' (BSD): Раздел 11.9.2 [Получение Датаграмм].
int RE_DUP_MAX
`limits.h' (POSIX.2): Раздел 27.1 [Основные Ограничения].
REG_BADBR
`regex.h' (POSIX.2): Раздел 16.3.1 [POSIX Компиляция Регулярных
выражений].
REG_BADPAT
`regex.h' (POSIX.2): Раздел 16.3.1 [POSIX Компиляция Регулярных
выражений].
REG_BADRPT
`regex.h' (POSIX.2): Раздел 16.3.1 [POSIX Компиляция Регулярных
выражений].
int regcomp (regex_t *compiled, const char *pattern, int cflags)
`regex.h' (POSIX.2):
Раздел 16.3.1 [POSIX Компиляция Регулярных выражений].
REG_EBRACE
`regex.h' (POSIX.2):
Раздел 16.3.1 [POSIX Компиляция Регулярных выражений].
REG_EBRACK
`regex.h' (POSIX.2):
Раздел 16.3.1 [POSIX Компиляция Регулярных выражений].
REG_ECOLLATE
`regex.h' (POSIX.2):
Раздел 16.3.1 [POSIX Компиляция Регулярных выражений].
REG_ECTYPE
`regex.h' (POSIX.2):
Раздел 16.3.1 [POSIX Компиляция Регулярных выражений].
REG_EESCAPE
`regex.h' (POSIX.2):
Раздел 16.3.1 [POSIX Компиляция Регулярных выражений].
REG_EPAREN
`regex.h' (POSIX.2):
Раздел 16.3.1 [POSIX Компиляция Регулярных выражений].
REG_ERANGE
`regex.h' (POSIX.2):
Раздел 16.3.1 [POSIX Компиляция Регулярных выражений].
size_t regerror (int errcode, regex_t *compiled, char *buffer,
size_t length)
`regex.h' (POSIX.2): Раздел 16.3.6 [Regexp Cleanup].
REG_ESPACE
`regex.h' (POSIX.2):
Раздел 16.3.3 [POSIX Соответствие Регулярных выражений].
REG_ESPACE
`regex.h' (POSIX.2):
Раздел 16.3.1 [POSIX Компиляция Регулярных выражений].
REG_ESUBREG
`regex.h' (POSIX.2):
Раздел 16.3.1 [POSIX Компиляция Регулярных выражений].
int regexec (regex_t *compiled, char *string, size_t nmatch,
regmatch_t matchptr [], int eflags)
`regex.h' (POSIX.2):
Раздел 16.3.3 [POSIX Соответствие Регулярных выражений].
REG_EXTENDED
`regex.h' (POSIX.2): Раздел 16.3.2 [Флаги для POSIX Regexps].
regex_t
`regex.h' (POSIX.2):
Раздел 16.3.1 [POSIX Компиляция Регулярных выражений].
void regfree (regex_t *compiled)
`regex.h' (POSIX.2): Раздел 16.3.6 [Очистка Regexp].
REG_ICASE
`regex.h' (POSIX.2): Раздел 16.3.2 [Флаги для POSIX Regexps].
int register_printf_function (int spec, printf_function handler
`function, printf_arginfo_function arginfo`function)
`printf.h' (GNU): Раздел 7.10.1 [Регистрация Новых Преобразований].
regmatch_t
`regex.h' (POSIX.2): Раздел 16.3.4 [Подвыражения].
REG_NEWLINE
`regex.h' (POSIX.2): Раздел 16.3.2 [Флаги для POSIX Regexps].
REG_NOMATCH
`regex.h' (POSIX.2):
Раздел 16.3.3 [POSIX Соответствие Регулярных выражений].
REG_NOSUB
`regex.h' (POSIX.2): Раздел 16.3.2 [Флаги для POSIX Regexps].
REG_NOTBOL
`regex.h' (POSIX.2):
Раздел 16.3.3 [POSIX Соответствие Регулярных выражений].
REG_NOTEOL
`regex.h' (POSIX.2):
Раздел 16.3.3 [POSIX Соответствие Регулярных выражений].
regoff_t
`regex.h' (POSIX.2): Раздел 16.3.4 [Подвыражения].
int remove (const char *filename)
`stdio.h' (ANSI): Раздел 9.5 [Удаление Файлов].
int rename (const char *oldname, const char *newname)
`stdio.h' (ANSI): Раздел 9.6 [Переименование Файлов].
void rewinddir (DIR *dirstream)
`dirent.h' (POSIX.1): Раздел 9.2.5 [Каталоги неопределенного доступа].
void rewind (FILE *stream)
`stdio.h' (ANSI): Раздел 7.15 [Позиционирование Файла].
char * rindex (const char *string, int c)
`string.h' (BSD): Раздел 5.7 [Функции Поиска].
double rint (double x)
`math.h' (BSD): Раздел 14.5 [Округление и Остаточные члены].
RLIMIT_CORE
`sys/resource.h' (BSD): Раздел 17.6 [Ограничения Ресурсов].
RLIMIT_CPU
`sys/resource.h' (BSD): Раздел 17.6 [Ограничения Ресурсов].
RLIMIT_DATA
`sys/resource.h' (BSD): Раздел 17.6 [Ограничения Ресурсов].
RLIMIT_FSIZE
`sys/resource.h' (BSD): Раздел 17.6 [Ограничения Ресурсов].
RLIMIT_OPEN_FILES
`sys/resource.h' (BSD): Раздел 17.6 [Ограничения Ресурсов].
RLIMIT_RSS
`sys/resource.h' (BSD): Раздел 17.6 [Ограничения Ресурсов].
RLIMIT_STACK
`sys/resource.h' (BSD): Раздел 17.6 [Ограничения Ресурсов].
RLIM_NLIMITS
`sys/resource.h' (BSD): Раздел 17.6 [Ограничения Ресурсов].
int rmdir (const char *filename)
`unistd.h' (POSIX.1): Раздел 9.5 [Удаление Файлов].
int R_OK
`unistd.h' (POSIX.1): Раздел 9.8.8 [Прверка Прав Файла].
void * r_re_alloc (void **handleptr, size_t size)
`malloc.h' (GNU): Раздел 3.6.2 [Распределение Переместимых Блоков].
RUSAGE_CHILDREN
`sys/resource.h' (BSD): Раздел 17.5 [Использование Ресурсов].
RUSAGE_SELF
`sys/resource.h' (BSD): Раздел 17.5 [Использование Ресурсов].
int SA_NOCLDSTOP
`signal.h' (POSIX.1): Раздел 21.3.5 [Флаги для Sigaction].
int SA_ONSTACK
`signal.h' (BSD): Раздел 21.3.5 [Флаги для Sigaction].
int SA_RESTART
`signal.h' (BSD): Раздел 21.3.5 [Флаги для Sigaction].
_SC_2_C_DEV
`unistd.h' (POSIX.2): Раздел 27.4.2 [Константы для Sysconf].
_SC_2_FORT_DEV
`unistd.h' (POSIX.2): Раздел 27.4.2 [Константы для Sysconf].
_SC_2_FORT_RUN
`unistd.h' (POSIX.2): Раздел 27.4.2 [Константы для Sysconf].
_SC_2_LOCALEDEF
`unistd.h' (POSIX.2): Раздел 27.4.2 [Константы для Sysconf].
_SC_2_SW_DEV
`unistd.h' (POSIX.2): Раздел 27.4.2 [Константы для Sysconf].
_SC_2_VERSION
`unistd.h' (POSIX.2): Раздел 27.4.2 [Константы для Sysconf].
double scalb (double value, int exponent)
`math.h' (BSD): Раздел 14.4 [Функции Нормализации].
int scanf (const char *template, . . .)
`stdio.h' (ANSI): Раздел 7.11.8 [Функции Форматированного Ввода].
_SC_ARG_MAX
`unistd.h' (POSIX.1): Раздел 27.4.2 [Константы для Sysconf].
_SC_BC_BASE_MAX
`unistd.h' (POSIX.2): Раздел 27.4.2 [Константы для Sysconf].
_SC_BC_DIM_MAX
`unistd.h' (POSIX.2): Раздел 27.4.2 [Константы для Sysconf].
_SC_BC_SCALE_MAX
`unistd.h' (POSIX.2): Раздел 27.4.2 [Константы для Sysconf].
_SC_BC_STRING_MAX
`unistd.h' (POSIX.2): Раздел 27.4.2 [Константы для Sysconf].
_SC_CHILD_MAX
`unistd.h' (POSIX.1): Раздел 27.4.2 [Константы для Sysconf].
_SC_CLK_TCK
`unistd.h' (POSIX.1): Раздел 27.4.2 [Константы для Sysconf].
_SC_COLL_WEIGHTS_MAX
`unistd.h' (POSIX.2): Раздел 27.4.2 [Константы для Sysconf].
_SC_EQUIV_CLASS_MAX
`unistd.h' (POSIX.2): Раздел 27.4.2 [Константы для Sysconf].
_SC_EXPR_NEST_MAX
`unistd.h' (POSIX.2): Раздел 27.4.2 [Константы для Sysconf].
SCHAR_MAX
`limits.h' (ANSI): Раздел A.5.2 [Диапазон Типа].
SCHAR_MIN
`limits.h' (ANSI): Раздел A.5.2 [Диапазон Типа].
_SC_JOB_CONTROL
`unistd.h' (POSIX.1): Раздел 27.4.2 [Константы для Sysconf].
_SC_LINE_MAX
`unistd.h' (POSIX.2): Раздел 27.4.2 [Константы для Sysconf].
_SC_NGROUPS_MAX
`unistd.h' (POSIX.1): Раздел 27.4.2 [Константы для Sysconf].
_SC_OPEN_MAX
`unistd.h' (POSIX.1): Раздел 27.4.2 [Константы для Sysconf].
_SC_PAGESIZE
`unistd.h' (GNU): Раздел 27.4.2 [Константы для Sysconf].
_SC_SAVED_IDS
`unistd.h' (POSIX.1): Раздел 27.4.2 [Константы для Sysconf].
_SC_STREAM_MAX
`unistd.h' (POSIX.1): Раздел 27.4.2 [Константы для Sysconf].
_SC_TZNAME_MAX
`unistd.h' (POSIX.1): Раздел 27.4.2 [Константы для Sysconf].
_SC_VERSION
`unistd.h' (POSIX.1): Раздел 27.4.2 [Константы для Sysconf].
_SC_VERSION
`unistd.h' (POSIX.2): Раздел 27.4.2 [Константы для Sysconf].
int SEEK_CUR
`stdio.h' (ANSI): Раздел 7.15 [Позиционирование Файла].
void seekdir (DIR *dirstream, off_t pos)
`dirent.h' (BSD): Раздел 9.2.5 [Доступ к Каталогам].
int SEEK_END
`stdio.h' (ANSI): Раздел 7.15 [Позиционирование Файла].
int SEEK_SET
`stdio.h' (ANSI): Раздел 7.15 [Позиционирование Файла].
int select (int nfds, fd_set *read`fds, fd_set *write`fds,
fd_set *except`fds, struct timeval *timeout)
`sys/types.h' (BSD): Раздел 8.6 [Ожидание Ввода/Вывода].
int send (int socket, void *buffer, size_t size, int flags)
`sys/socket.h' (BSD): Раздел 11.8.5.1 [Посылка Данных].
int sendmsg (int socket, const struct msghdr *message, int flags)
`sys/socket.h' (BSD): Раздел 11.9.2 [Получение Датаграмм].
int sendto (int socket, void *buffer. size_t size, int flags,
struct sockaddr *addr, size_t length)
`sys/socket.h' (BSD): Раздел 11.9.1 [Посылка Datagrams].
void setbuffer (FILE *stream, char *buf, size_t size)
`stdio.h' (BSD): Раздел 7.17.3 [Буферизация Управления].
void setbuf (FILE *stream, char *buf )
`stdio.h' (ANSI): Раздел 7.17.3 [Буферизация Управления].
int setgid (gid_t newgid)
`unistd.h' (POSIX.1): Раздел 25.7 [Установка Группы].
void setgrent (void)
`grp.h' (SVID, BSD): Раздел 25.13.3 [Просмотр Всех Групп].
int setgroups (size_t count, gid_t *groups)
`grp.h' (BSD): Раздел 25.7 [Установка Группы].
void sethostent (int stayopen)
`netdb.h' (BSD): Раздел 11.5.2.4 [Главные Имена].
int sethostid (long int id)
`unistd.h' (BSD): Раздел 26.1 [Главная Идентификация].
int sethostname (const char *name, size_t length)
`unistd.h' (BSD): Раздел 26.1 [Главная Идентификация].
int setitimer (int which, struct itimerval *old, struct itimerval *new)
`sys/time.h' (BSD): Раздел 17.3 [Установка Сигнализации].
int setjmp (jmp_buf state)
`setjmp.h' (ANSI): Раздел 20.2 [Не-локальные Подробности].
void setlinebuf (FILE *stream)
`stdio.h' (BSD): Раздел 7.17.3 [Буферизация Управления].
char * setlocale (int category, const char *locale)
`locale.h' (ANSI): Раздел 19.4 [Установка Стандарта].
void setnetent (int stayopen)
`netdb.h' (BSD): Раздел 11.12 [База данных Сетей].
int setpgid (pid_t pid, pid_t pgid)
`unistd.h' (POSIX.1): Раздел 24.7.2 [Функции Группы Процессов].
int setpgrp (pid_t pid, pid_t pgid)
`unistd.h' (BSD): Раздел 24.7.2 [Функции Группы Процессов].
int setpriority (int class, int id, int priority)
`sys/resource.h' (BSD): Раздел 17.7 [Приоритет].
void setprotoent (int stayopen)
`netdb.h' (BSD): Раздел 11.5.6 [База данных Протоколов].
void setpwent (void)
`pwd.h' (SVID, BSD): Раздел 25.12.3 [Просмотр Всех Пользователей].
int setregid (gid_t rgid, fid_t egid)
`unistd.h' (BSD): Раздел 25.7 [Установка Группы].
int setreuid (uid_t ruid, uid_t euid)
`unistd.h' (BSD): Раздел 25.6 [Утановка Пользовательского ID].
int setrlimit (int resource, struct rlimit *rlp)
`sys/resource.h' (BSD): Раздел 17.6 [Ограничения Ресурсов].
void setservent (int stayopen)
`netdb.h' (BSD): Раздел 11.5.4 [База Данных Услуг].
pid_t setsid (void)
`unistd.h' (POSIX.1): Раздел 24.7.2 [Функции Группы Процессов].
int setsockopt (int socket, int level, int optname, void *optval,
size_t optlen)
`sys/socket.h' (BSD): Раздел 11.11.1 [Функции для Опций Гнезда].
void * setstate (void *state)
`stdlib.h' (BSD): Раздел 13.6.2 [BSD Random].
int settimeofday (const struct timeval *tp, const struct timezone *tzp) `sys/time.h' (BSD):
Раздел 17.2.2 [Точный Календарь].
int setuid (uid_t newuid)
`unistd.h' (POSIX.1): Раздел 25.6 [Утановка Пользовательского ID].
int setvbuf (FILE *stream, char *buf, int mode, size_t size)
`stdio.h' (ANSI): Раздел 7.17.3 [Буферизация Управления].
SHRT_MAX
`limits.h' (ANSI): Раздел A.5.2 [Диапазон Типа].
SHRT_MIN
`limits.h' (ANSI): Раздел A.5.2 [Диапазон Типа].
int shutdown (int socket, int how)
`sys/socket.h' (BSD): Раздел 11.7.2 [Закрытие Гнезда].
S_IEXEC
`sys/stat.h' (BSD): Раздел 9.8.5 [Биты Прав].
S_IFBLK
`sys/stat.h' (BSD): Раздел 9.8.3 [Проверка Типа Файла].
S_IFCHR
`sys/stat.h' (BSD): Раздел 9.8.3 [Проверка Типа Файла].
S_IFDIR
`sys/stat.h' (BSD): Раздел 9.8.3 [Проверка Типа Файла].
S_IFIFO
`sys/stat.h' (BSD): Раздел 9.8.3 [Проверка Типа Файла].
S_IFLNK
`sys/stat.h' (BSD): Раздел 9.8.3 [Проверка Типа Файла].
int S_IFMT
`sys/stat.h' (BSD): Раздел 9.8.3 [Проверка Типа Файла].
S_IFREG
`sys/stat.h' (BSD): Раздел 9.8.3 [Проверка Типа Файла].
S_IFSOCK
`sys/stat.h' (BSD): Раздел 9.8.3 [Проверка Типа Файла].
int SIGABRT
`signal.h' (ANSI): Раздел 21.2.1 [Сигналы Ошибки в Программе].
int sigaction (int signum, const struct sigaction *action,
struct sigaction *old`action)
`signal.h' (POSIX.1): Раздел 21.3.2 [Соглашение Обработки Сигналов].
int sigaddset (sigset_t *set, int signum)
`signal.h' (POSIX.1): Раздел 21.7.2 [Множества Сигналов].
int SIGALRM
`signal.h' (POSIX.1): Раздел 21.2.3 [Сигналы таймера].
int sigaltstack (const struct sigaltstack *stack, struct sigaltstack
*oldstack)
`signal.h' (BSD): Раздел 21.10.2 [Стек Сигнала].
sig_atomic_t
`signal.h' (ANSI): Раздел 21.4.7.2 [Быстрые Типы].
int sigblock (int mask)
`signal.h' (BSD): Раздел 21.10.1 [Блокирование BSD].
SIG_BLOCK
`signal.h' (POSIX.1): Раздел 21.7.3 [Маска Сигналов Процесса].
int SIGBUS
`signal.h' (BSD): Раздел 21.2.1 [Сигналы Ошибки в Программе].
int SIGCHLD
`signal.h' (POSIX.1): Раздел 21.2.5 [Сигналы Контроля Заданий].
int SIGCONT
`signal.h' (POSIX.1): Раздел 21.2.5 [Сигналы Контроля Заданий].
int sigdelset (sigset_t *set, int signum)
`signal.h' (POSIX.1): Раздел 21.7.2 [Множества Сигналов].
int sigemptyset (sigset_t *set)
`signal.h' (POSIX.1): Раздел 21.7.2 [Множества Сигналов].
sighandler_t SIG_ERR
`signal.h' (ANSI): Раздел 21.3.1 [Основная Обработка Сигнала].
int sigfillset (sigset_t *set)
`signal.h' (POSIX.1): Раздел 21.7.2 [Множества Сигналов].
int SIGFPE
`signal.h' (ANSI): Раздел 21.2.1 [Сигналы Ошибки в Программе].
sighandler_t
`signal.h' (GNU): Раздел 21.3.1 [Основная Обработка Сигнала].
int SIGHUP
`signal.h' (POSIX.1): Раздел 21.2.2 [Сигналы Завершения].
int SIGILL
`signal.h' (ANSI): Раздел 21.2.1 [Сигналы Ошибки в Программе].
int siginterrupt (int signum, int failflag)
`signal.h' (BSD): Раздел 21.10 [BSD Обработчик].
int SIGINT
`signal.h' (ANSI): Раздел 21.2.2 [Сигналы Завершения].
int SIGIO
`signal.h' (BSD): Раздел 21.2.4 [Асинхронные Сигналы Ввода/Вывода].
int sigismember (const sigset_t *set, int signum)
`signal.h' (POSIX.1): Раздел 21.7.2 [Множества Сигналов].
sigjmp_buf
`setjmp.h' (POSIX.1): Раздел 20.3 [Не-локальные Выходы и Сигналы].
int SIGKILL
`signal.h' (POSIX.1): Раздел 21.2.2 [Сигналы Завершения].
void siglongjmp (sigjmp_buf state, int value)
`setjmp.h' (POSIX.1): Раздел 20.3 [Не-локальные Выходы и Сигналы].
int sigmask (int signum)
`signal.h' (BSD): Раздел 21.10.1 [Блокирование BSD].
sighandler_t signal (int signum, sighandler_t action)
`signal.h' (ANSI): Раздел 21.3.1 [Основная Обработка Сигнала].
int sigpause (int mask)
`signal.h' (BSD): Раздел 21.10.1 [Блокирование BSD].
int sigpending (sigset_t *set)
`signal.h' (POSIX.1): Раздел 21.7.6 [Проверка Отложенных Сигналов].
int SIGPIPE
`signal.h' (POSIX.1): Раздел 21.2.6 [Разнообразные Сигналы].
int sigprocmask (int how, const sigset_t *set, sigset_t *oldset)
`signal.h' (POSIX.1): Раздел 21.7.3 [Маска Сигналов Процесса].
int SIGPROF
`signal.h' (BSD): Раздел 21.2.3 [Сигналы таймера].
int SIGQUIT
`signal.h' (POSIX.1): Раздел 21.2.2 [Сигналы Завершения].
int SIGSEGV
`signal.h' (ANSI): Раздел 21.2.1 [Сигналы Ошибки в Программе].
int sigsetjmp (sigjmp_buf state, int savesigs)
`setjmp.h' (POSIX.1): Раздел 20.3 [Не-локальные Выходы и Сигналы].
int sigsetmask (int mask)
`signal.h' (BSD): Раздел 21.10.1 [Блокирование BSD].
SIG_SETMASK
`signal.h' (POSIX.1): Раздел 21.7.3 [Маска Сигналов Процесса].
sigset_t
`signal.h' (POSIX.1): Раздел 21.7.2 [Множества Сигналов].
int sigstack (const struct sigstack *stack, struct sigstack *oldstack)
`signal.h' (BSD): Раздел 21.10.2 [Стек Сигнала].
int SIGSTOP
`signal.h' (POSIX.1): Раздел 21.2.5 [Сигналы Контроля Заданий].
int sigsuspend (const sigset_t *set)
`signal.h' (POSIX.1): Раздел 21.8.3 [Sigsuspend].
int SIGTERM
`signal.h' (ANSI): Раздел 21.2.2 [Сигналы Завершения].
int SIGTSTP
`signal.h' (POSIX.1): Раздел 21.2.5 [Сигналы Контроля Заданий].
int SIGTTIN
`signal.h' (POSIX.1): Раздел 21.2.5 [Сигналы Контроля Заданий].
int SIGTTOU
`signal.h' (POSIX.1): Раздел 21.2.5 [Сигналы Контроля Заданий].
SIG_UNBLOCK
`signal.h' (POSIX.1): Раздел 21.7.3 [Маска Сигналов Процесса].
int SIGURG
`signal.h' (BSD): Раздел 21.2.4 [Асинхронные Сигналы Ввода/Вывода].
int SIGUSR1
`signal.h' (POSIX.1): Раздел 21.2.6 [Разнообразные Сигналы].
int SIGUSR2
`signal.h' (POSIX.1): Раздел 21.2.6 [Разнообразные Сигналы].
int sigvec (int signum, const struct sigvec *action,struct sigvec
*old`action)
`signal.h' (BSD): Раздел 21.10 [BSD Обработчик].
int SIGVTALRM
`signal.h' (BSD): Раздел 21.2.3 [Сигналы таймера].
double sinh (double x)
`math.h' (ANSI): Раздел 13.5 [Гиперболические функции].
double sin (double x)
`math.h' (ANSI): Раздел 13.2 [Тригонометрические Функции].
S_IREAD
`sys/stat.h' (BSD): Раздел 9.8.5 [Биты Прав].
S_IRGRP
`sys/stat.h' (POSIX.1): Раздел 9.8.5 [Биты Прав].
S_IROTH
`sys/stat.h' (POSIX.1): Раздел 9.8.5 [Биты Прав].
S_IRUSR
`sys/stat.h' (POSIX.1): Раздел 9.8.5 [Биты Прав].
S_IRWXG
`sys/stat.h' (POSIX.1): Раздел 9.8.5 [Биты Прав].
S_IRWXO
`sys/stat.h' (POSIX.1): Раздел 9.8.5 [Биты Прав].
S_IRWXU
`sys/stat.h' (POSIX.1): Раздел 9.8.5 [Биты Прав].
int S_ISBLK (mode_t m)
`sys/stat.h' (POSIX): Раздел 9.8.3 [Проверка Типа Файла].
int S_ISCHR (mode_t m)
`sys/stat.h' (POSIX): Раздел 9.8.3 [Проверка Типа Файла].
int S_ISDIR (mode_t m)
`sys/stat.h' (POSIX): Раздел 9.8.3 [Проверка Типа Файла].
int S_ISFIFO (mode_t m)
`sys/stat.h' (POSIX): Раздел 9.8.3 [Проверка Типа Файла].
S_ISGID
`sys/stat.h' (POSIX): Раздел 9.8.5 [Биты Прав].
int S_ISLNK (mode_t m)
`sys/stat.h' (GNU): Раздел 9.8.3 [Проверка Типа Файла].
int S_ISREG (mode_t m)
`sys/stat.h' (POSIX): Раздел 9.8.3 [Проверка Типа Файла].
int S_ISSOCK (mode_t m)
`sys/stat.h' (GNU): Раздел 9.8.3 [Проверка Типа Файла].
S_ISUID
`sys/stat.h' (POSIX): Раздел 9.8.5 [Биты Прав].
S_ISVTX
`sys/stat.h' (BSD): Раздел 9.8.5 [Биты Прав].
S_IWGRP
`sys/stat.h' (POSIX.1): Раздел 9.8.5 [Биты Прав].
S_IWOTH
`sys/stat.h' (POSIX.1): Раздел 9.8.5 [Биты Прав].
S_IWRITE
`sys/stat.h' (BSD): Раздел 9.8.5 [Биты Прав].
S_IWUSR
`sys/stat.h' (POSIX.1): Раздел 9.8.5 [Биты Прав].
S_IXGRP
`sys/stat.h' (POSIX.1): Раздел 9.8.5 [Биты Прав].
S_IXOTH
`sys/stat.h' (POSIX.1): Раздел 9.8.5 [Биты Прав].
S_IXUSR
`sys/stat.h' (POSIX.1): Раздел 9.8.5 [Биты Прав].
size_t
`stddef.h' (ANSI): Раздел A.4 [Важные Типы Данных].
unsigned int sleep (unsigned int seconds)
`unistd.h' (POSIX.1): Раздел 17.4 [Sleeping].
int snprintf (char *s, size_t size, const char *template, . . .)
`stdio.h' (GNU): Раздел 7.9.7 [Функции Форматированного Вывода].
SO_BROADCAST
`sys/socket.h' (BSD): Раздел 11.11.2 [Опции Гнезда].
int SOCK_DGRAM
`sys/socket.h' (BSD): Раздел 11.2 [Стили Связи].
int socket (int namespace, int style, int protocol)
`sys/socket.h' (BSD): Раздел 11.7.1 [Создание Гнезда].
int socketpair (int namespace, int style, int protocol, int filedes[2])
`sys/socket.h' (BSD): Раздел 11.7.3 [Пары Гнезд].
int SOCK_RAW
`sys/socket.h' (BSD): Раздел 11.2 [Стили Связи].
int SOCK_RDM
`sys/socket.h' (BSD): Раздел 11.2 [Стили Связи].
int SOCK_SEQPACKET
`sys/socket.h' (BSD): Раздел 11.2 [Стили Связи].
int SOCK_STREAM
`sys/socket.h' (BSD): Раздел 11.2 [Стили Связи].
SO_DEBUG
`sys/socket.h' (BSD): Раздел 11.11.2 [Опции Гнезда].
SO_DONTROUTE
`sys/socket.h' (BSD): Раздел 11.11.2 [Опции Гнезда].
SO_ERROR
`sys/socket.h' (BSD): Раздел 11.11.2 [Опции Гнезда].
SO_KEEPALIVE
`sys/socket.h' (BSD): Раздел 11.11.2 [Опции Гнезда].
SO_LINGER
`sys/socket.h' (BSD): Раздел 11.11.2 [Опции Гнезда].
int SOL_SOCKET
`sys/socket.h' (BSD): Раздел 11.11.2 [Опции Гнезда].
SO_OOBINLINE
`sys/socket.h' (BSD): Раздел 11.11.2 [Опции Гнезда].
SO_RCVBUF
`sys/socket.h' (BSD): Раздел 11.11.2 [Опции Гнезда].
SO_REUSEADDR
`sys/socket.h' (BSD): Раздел 11.11.2 [Опции Гнезда].
SO_SNDBUF
`sys/socket.h' (BSD): Раздел 11.11.2 [Опции Гнезда].
SO_STYLE
`sys/socket.h' (GNU): Раздел 11.11.2 [Опции Гнезда].
SO_TYPE
`sys/socket.h' (BSD): Раздел 11.11.2 [Опции Гнезда].
speed_t
`termios.h' (POSIX.1): Раздел 12.4.8 [Скорость Строки].
int sprintf (char *s, const char *template, . . .)
`stdio.h' (ANSI): Раздел 7.9.7 [Функции Форматированного Вывода].
double sqrt (double x)
`math.h' (ANSI): Раздел 13.4 [Экспоненты и Логарифмы].
void srand (unsigned int seed)
`stdlib.h' (ANSI): Раздел 13.6.1 [ANSI Random].
void srandom (unsigned int seed)
`stdlib.h' (BSD): Раздел 13.6.2 [BSD Random].
int sscanf (const char *s, const char *template, . . .)
`stdio.h' (ANSI): Раздел 7.11.8 [Функции Форматированного Ввода].
sighandler_t ssignal (int signum, sighandler_t action)
`signal.h' (SVID): Раздел 21.3.1 [Основная Обработка Сигнала].
int SSIZE_MAX
`limits.h' (POSIX.1): Раздел 27.1 [Основные Ограничения].
ssize_t
`unistd.h' (POSIX.1): Раздел 8.2 [Прмитивы Ввода/Вывода].
int stat (const char *filename, struct stat *buf )
`sys/stat.h' (POSIX.1): Раздел 9.8.2 [Чтение Атрибутов].
STDERR_FILENO
`unistd.h' (POSIX.1): Раздел 8.4 [Описатели и Потоки].
FILE * stderr
`stdio.h' (ANSI): Раздел 7.2 [Стандартные Потоки].
STDIN_FILENO
`unistd.h' (POSIX.1): Раздел 8.4 [Описатели и Потоки].
FILE * stdin
`stdio.h' (ANSI): Раздел 7.2 [Стандартные Потоки].
STDOUT_FILENO
`unistd.h' (POSIX.1): Раздел 8.4 [Описатели и Потоки].
FILE * stdout
`stdio.h' (ANSI): Раздел 7.2 [Стандартные Потоки].
char * stpcpy (char *to, const char *from)
`string.h' (Unknown origin): Раздел 5.4 [Копирование и Конкатенация].
int strcasecmp (const char *s1, const char *s2)
`string.h' (BSD): Раздел 5.5 [Сравнение Строки/Массива].
char * strcat (char *to, const char *from)
`string.h' (ANSI): Раздел 5.4 [Копирование и Конкатенация].
char * strchr (const char *string, int c)
`string.h' (ANSI): Раздел 5.7 [Функции Поиска].
int strcmp (const char *s1, const char *s2)
`string.h' (ANSI): Раздел 5.5 [Сравнение Строки/Массива].
int strcoll (const char *s1, const char *s2)
`string.h' (ANSI): Раздел 5.6 [Функции Объединения].
char * strcpy (char *to, const char *from)
`string.h' (ANSI): Раздел 5.4 [Копирование и Конкатенация].
size_t strcspn (const char *string, const char *stopset)
`string.h' (ANSI): Раздел 5.7 [Функции Поиска].
char * strdup (const char *s)
`string.h' (SVID): Раздел 5.4 [Копирование и Конкатенация].
int STREAM_MAX
`limits.h' (POSIX.1): Раздел 27.1 [Основные Ограничения].
char * strerror (int errnum)
`string.h' (ANSI): Раздел 2.3 [Сообщения об Ошибках].
size_t strftime (char *s, size_t size, const char *template,
const struct tm *brokentime)
`time.h' (ANSI): Раздел 17.2.4 [Форматирование Даты и Времени].
size_t strlen (const char *s)
`string.h' (ANSI): Раздел 5.3 [Длина Строки].
int strncasecmp (const char *s1, const char *s2, size_t n)
`string.h' (BSD): Раздел 5.5 [Сравнение Строки/Массива].
char * strncat (char *to, const char *from, size_t size)
`string.h' (ANSI): Раздел 5.4 [Копирование и Конкатенация].
int strncmp (const char *s1, const char *s2, size_t size)
`string.h' (ANSI): Раздел 5.5 [Сравнение Строки/Массива].
char * strncpy (char *to, const char *from, size_t size)
`string.h' (ANSI): Раздел 5.4 [Копирование и Конкатенация].
char * strpbrk (const char *string, const char *stopset)
`string.h' (ANSI): Раздел 5.7 [Функции Поиска].
char * strrchr (const char *string, int c)
`string.h' (ANSI): Раздел 5.7 [Функции Поиска].
char * strsignal (int signum)
`string.h' (GNU): Раздел 21.2.8 [Сообщения Сигналов].
size_t strspn (const char *string, const char *skipset)
`string.h' (ANSI): Раздел 5.7 [Функции Поиска].
char * strstr (const char *haystack, const char *needle)
`string.h' (ANSI): Раздел 5.7 [Функции Поиска].
double strtod (const char *string, char **tailptr)
`stdlib.h' (ANSI): Раздел 14.7.2 [Синтаксический анализ с
Плавающей Точкой].
char * strtok (char *newstring, const char *delimiters)
`string.h' (ANSI): Раздел 5.8 [Поиск].
long int strtol (const char *string, char **tailptr, int base)
`stdlib.h' (ANSI): Раздел 14.7.1 [Синтаксический анализ Целых чисел].
unsigned long int strtoul (const char *string, char **tailptr, int base)
`stdlib.h' (ANSI): Раздел 14.7.1 [Синтаксический анализ Целых чисел].
struct cookie_io_functions
`stdio.h' (GNU): Раздел 7.18.3.1 [Потоки и Cookie].
struct dirent
`dirent.h' (POSIX.1): Раздел 9.2.1 [Входы Каталога].
struct flock
`fcntl.h' (POSIX.1): Раздел 8.11 [Блокировки Файла].
struct group
`grp.h' (POSIX.1): Раздел 25.13.1 [Структура Данных Групп].
struct hostent
`netdb.h' (BSD): Раздел 11.5.2.4 [Главные Имена].
struct in_addr
`netinet/in.h' (BSD): Раздел 11.5.2.2 [Главный Адрес (тип_данных)].
struct itimerval
`sys/time.h' (BSD): Раздел 17.3 [Установка Сигнализации].
struct lconv
`locale.h' (ANSI): Раздел 19.6 [Форматирование Чисел].
struct linger
`sys/socket.h' (BSD): Раздел 11.11.2 [Опции Гнезда].
struct msghdr
`sys/socket.h' (BSD): Раздел 11.9.2 [Получение Датаграмм].
struct mstats
`malloc.h' (GNU): Раздел 3.3.10 [Статистика Malloc].
struct netent
`netdb.h' (BSD): Раздел 11.12 [База данных Сетей].
struct obstack
`obstack.h' (GNU): Раздел 3.4.1 [Создание Obstack].
struct option
`getopt.h' (GNU): Раздел 22.1.4 [Длинные Опции].
struct passwd
`pwd.h' (POSIX.1): Раздел 25.12.1 [Структура Данных Пользователей].
struct printf_info
`printf.h' (GNU): Раздел 7.10.2 [Опции Преобразований].
struct protoent
`netdb.h' (BSD): Раздел 11.5.6 [База данных Протоколов].
struct rlimit
`sys/resource.h' (BSD): Раздел 17.6 [Ограничения Ресурсов].
struct rusage
`sys/resource.h' (BSD): Раздел 17.5 [Использование Ресурсов].
struct servent
`netdb.h' (BSD): Раздел 11.5.4 [База Данных Услуг].
struct sigaction
`signal.h' (POSIX.1): Раздел 21.3.2 [Обработка Сигналов].
struct sigaltstack
`signal.h' (BSD): Раздел 21.10.2 [Стек Сигнала].
struct sigstack
`signal.h' (BSD): Раздел 21.10.2 [Стек Сигнала].
struct sigvec
`signal.h' (BSD): Раздел 21.10 [BSD Обработчик].
struct sockaddr
`sys/socket.h' (BSD): Раздел 11.3.1 [Форматы Адреса].
struct sockaddr_in
`netinet/in.h' (BSD): Раздел 11.5.1 [Формат Адреса Internet].
struct sockaddr_un
`sys/un.h' (BSD): Раздел 11.4.2 [Именное Пространство Файла].
struct stat
`sys/stat.h' (POSIX.1): Раздел 9.8.1 [Значения Атрибутов].
struct termios
`termios.h' (POSIX.1): Раздел 12.4.1 [Типы Данных Режимов].
struct timeval
`sys/time.h' (BSD): Раздел 17.2.2 [Точный Календарь].
struct timezone
`sys/time.h' (BSD): Раздел 17.2.2 [Точный Календарь].
struct tm
`time.h' (ANSI): Раздел 17.2.3 [Сброшенное Время].
struct tms
`sys/times.h' (POSIX.1): Раздел 17.1.2 [Уточненное Время CPU].
struct utimbuf
`time.h' (POSIX.1): Раздел 9.8.9 [Времена файла].
struct utsname
`sys/utsname.h' (POSIX.1): Раздел 26.2 [ИДЕНТИЧНОСТЬ для АППАРАТНЫХ
СРЕДСТВ/ПРОГРАММНОГО ОБЕСПЕЧЕНИЯ].
size_t strxfrm (char *to, const char *from, size_t size)
`string.h' (ANSI): Раздел 5.6 [Функции объединения].
_SVID_SOURCE
(GNU): Раздел 1.3.4 [Макрокоманды Возможностей].
int SV_INTERRUPT
`signal.h' (BSD): Раздел 21.10 [BSD Обработчик].
int SV_ONSTACK
`signal.h' (BSD): Раздел 21.10 [BSD Обработчик].
int SV_RESETHAND
`signal.h' (Sun): Раздел 21.10 [BSD Обработчик].
int symlink (const char *oldname, const char *newname)
`unistd.h' (BSD): Раздел 9.4 [Символические Связи].
long int sysconf (int parameter)
`unistd.h' (POSIX.1): Раздел 27.4.1 [Sysconf].
int system (const char *command)
`stdlib.h' (ANSI): Раздел 23.1 [Выполнение Команды].
double tanh (double x)
`math.h' (ANSI): Раздел 13.5 [Гиперболические функции].
double tan (double x)
`math.h' (ANSI): Раздел 13.2 [Тригонометрические Функции].
int tcdrain (int filedes)
`termios.h' (POSIX.1): Раздел 12.5 [Управление строки].
tcflag_t
`termios.h' (POSIX.1): Раздел 12.4.1 [Типы Данных Режима].
int tcflow (int filedes, int action)
`termios.h' (POSIX.1): Раздел 12.5 [Управление строки].
int tcflush (int filedes, int queue)
`termios.h' (POSIX.1): Раздел 12.5 [Управление строки].
int tcgetattr (int filedes, struct termios *termios`p)
`termios.h' (POSIX.1): Раздел 12.4.2 [Функции Режима].
pid_t tcgetpgrp (int filedes)
`unistd.h' (POSIX.1): Раздел 24.7.3 [Функции Доступа к Терминалу].
TCSADRAIN
`termios.h' (POSIX.1): Раздел 12.4.2 [Функции Режима].
TCSAFLUSH
`termios.h' (POSIX.1): Раздел 12.4.2 [Функции Режима].
TCSANOW
`termios.h' (POSIX.1): Раздел 12.4.2 [Функции Режима].
TCSASOFT
`termios.h' (BSD): Раздел 12.4.2 [Функции Режима].
int tcsendbreak (int filedes, int duration)
`termios.h' (POSIX.1): Раздел 12.5 [Управление строки].
int tcsetattr (int filedes, int when, const struct termios *termios`p)
`termios.h' (POSIX.1): Раздел 12.4.2 [Функции Режима].
int tcsetpgrp (int filedes, pid_t pgid)
`unistd.h' (POSIX.1): Раздел 24.7.3 [Функции Доступа к Терминалу].
off_t telldir (DIR *dirstream)
`dirent.h' (BSD): Раздел 9.2.5 [Доступ к Каталогу].
TEMP_FAILURE_RETRY (expression)
`unistd.h' (GNU): Раздел 21.5 [Прерванные Примитивы].
char * tempnam (const char *dir, const char *prefix)
`stdio.h' (SVID): Раздел 9.10 [Временные Файлы].
time_t time (time_t *result)
`time.h' (ANSI): Раздел 17.2.1 [Простое Календарное Время].
clock_t times (struct tms *buffer)
`sys/times.h' (POSIX.1): Раздел 17.1.2 [Уточненное Время CPU].
time_t
`time.h' (ANSI): Раздел 17.2.1 [Простое Календарное Время].
long int timezone
`time.h' (SVID): Раздел 17.2.6 [Функции для Временной Зоны].
FILE * tmpfile (void)
`stdio.h' (ANSI): Раздел 9.10 [Временные Файлы].
int TMP_MAX
`stdio.h' (ANSI): Раздел 9.10 [Временные Файлы].
char * tmpnam (char *result)
`stdio.h' (ANSI): Раздел 9.10 [Временные Файлы].
int toascii (int c)
`ctype.h' (SVID, BSD): Раздел 4.2 [Преобразование Регистра].
int tolower (int c)
`ctype.h' (ANSI): Раздел 4.2 [Преобразование Регистра].
int _tolower (int c)
`ctype.h' (SVID): Раздел 4.2 [Преобразование Регистра].
TOSTOP
`termios.h' (POSIX.1): Раздел 12.4.7 [Автономные режимы].
int toupper (int c)
`ctype.h' (ANSI): Раздел 4.2 [Преобразование Регистра].
int _toupper (int c)
`ctype.h' (SVID): Раздел 4.2 [Преобразование Регистра].
TRY_AGAIN
`netdb.h' (BSD): Раздел 11.5.2.4 [Главные Имена].
char * ttyname (int filedes)
`unistd.h' (POSIX.1): Раздел 12.1 [Терминал ли это].
int TZNAME_MAX
`limits.h' (POSIX.1): Раздел 27.1 [Основные Ограничения].
void tzset (void)
`time.h' (POSIX.1): Раздел 17.2.6 [Функции для Временной Зоны].
UCHAR_MAX
`limits.h' (ANSI): Раздел A.5.2 [Диапазон Типа].
uid_t
`sys/types.h' (POSIX.1): Раздел 25.5 [Чтение Persona].
UINT_MAX
`limits.h' (ANSI): Раздел A.5.2 [Диапазон Типа].
ULONG_LONG_MAX
`limits.h' (ANSI): Раздел A.5.2 [Диапазон Типа].
ULONG_MAX
`limits.h' (ANSI): Раздел A.5.2 [Диапазон Типа].
mode_t umask (mode_t mask)
`sys/stat.h' (POSIX.1): Раздел 9.8.7 [Установка Прав].
int uname (struct utsname *info)
`sys/utsname.h' (POSIX.1): Раздел 26.2 [ИДЕНТИЧНОСТЬ для ПО].
int ungetc (int c, FILE *stream)
`stdio.h' (ANSI): Раздел 7.8.2 [Unread].
union wait
`sys/wait.h' (BSD): Раздел 23.8 [BSD Функции Ожидания].
int unlink (const char *filename)
`unistd.h' (POSIX.1): Раздел 9.5 [Удаление Файлов].
USHRT_MAX
`limits.h' (ANSI): Раздел A.5.2 [Диапазон Типа].
int utime (const char *filename, const struct utimbuf *times)
`time.h' (POSIX.1): Раздел 9.8.9 [Времена файла].
int utimes (const char *filename, struct timeval tvp[2])
`sys/time.h' (BSD): Раздел 9.8.9 [Времена файла].
va_alist
`varargs.h' (Unix): Раздел A.2.3.1 [Старые Varargs].
type va_arg (va_list ap, type)
`stdarg.h' (ANSI): Раздел A.2.2.5 [Макросы Аргумента].
va_dcl
`varargs.h' (Unix): Раздел A.2.3.1 [Varargs].
void va_end (va_list ap)
`stdarg.h' (ANSI): Раздел A.2.2.5 [Макросы Аргумента].
va_list
`stdarg.h' (ANSI): Раздел A.2.2.5 [Макросы Аргумента].
void * valloc (size_t size)
`malloc.h', `stdlib.h' (BSD): Раздел 3.3.7 [Выравниваемые Блоки Памяти].
int vasprintf (char **ptr, const char *template, va_list ap)
`stdio.h' (GNU): Раздел 7.9.9 [Вывод с Переменными Аргументами].
void va_start (va_list ap)
`varargs.h' (Unix): Раздел A.2.3.1 [Varargs].
void va_start (va_list ap, last`required)
`stdarg.h' (ANSI): Раздел A.2.2.5 [Макросы Аргумента].
int VDISCARD
`termios.h' (BSD): Раздел 12.4.9.5 [Другой Выбор].
int VDSUSP
`termios.h' (BSD): Раздел 12.4.9.3 [Символы Сигнала].
int VEOF
`termios.h' (POSIX.1): Раздел 12.4.9.1 [Символы Редактирования].
int VEOL2
`termios.h' (BSD): Раздел 12.4.9.2 [BSD Редактирование].
int VEOL
`termios.h' (POSIX.1): Раздел 12.4.9.1 [Символы Редактирования].
int VERASE
`termios.h' (POSIX.1): Раздел 12.4.9.1 [Символы Редактирования].
pid_t vfork (void)
`unistd.h' (BSD): Раздел 23.4 [Создание Процесса].
int vfprintf (FILE *stream, const char *template, va_list ap)
`stdio.h' (ANSI): Раздел 7.9.9 [Вывод с Переменными Аргументами].
int vfscanf (FILE *stream, const char *template, va_list ap)
`stdio.h' (GNU): Раздел 7.11.9 [Ввод с Переменными Аргументами].
int VINTR
`termios.h' (POSIX.1): Раздел 12.4.9.3 [Символы Сигнала].
int VKILL
`termios.h' (POSIX.1): Раздел 12.4.9.1 [Символы Редактирования].
int VLNEXT
`termios.h' (BSD): Раздел 12.4.9.2 [BSD Редактирование].
int VMIN
`termios.h' (POSIX.1): Раздел 12.4.10 [Неканоническиий Ввод].
int vprintf (const char *template, va_list ap)
`stdio.h' (ANSI): Раздел 7.9.9 [Вывод с Переменными Аргументами].
int VQUIT
`termios.h' (POSIX.1): Раздел 12.4.9.3 [Символы Сигнала].
int VREPRINT
`termios.h' (BSD): Раздел 12.4.9.2 [BSD Редактирование].
int vscanf (const char *template, va_list ap)
`stdio.h' (GNU): Раздел 7.11.9 [Ввод с Переменными Аргументами].
int vsnprintf (char *s, size_t size, const char *template, va_list ap)
`stdio.h' (GNU): Раздел 7.9.9 [Вывод с Переменными Аргументами].
int vsprintf (char *s, const char *template, va_list ap)
`stdio.h' (ANSI): Раздел 7.9.9 [Вывод с Переменными Аргументами].
int vsscanf (const char *s, const char *template, va_list ap)
`stdio.h' (GNU): Раздел 7.11.9 [Ввод с Переменными Аргументами].
int VSTART
`termios.h' (POSIX.1): Раздел 12.4.9.4 [Символы Начала/Останова].
int VSTATUS
`termios.h' (BSD): Раздел 12.4.9.5 [Другой Выбор].
int VSTOP
`termios.h' (POSIX.1): Раздел 12.4.9.4 [Символы Начала/Останова].
int VSUSP
`termios.h' (POSIX.1): Раздел 12.4.9.3 [Символы Сигнала].
int VTIME
`termios.h' (POSIX.1): Раздел 12.4.10 [Неканоническиий Ввод].
int VWERASE
`termios.h' (BSD): Раздел 12.4.9.2 [BSD Редактирование].
pid_t wait3 (union wait *status`ptr, int options, struct rusage *usage)
`sys/wait.h' (BSD): Раздел 23.8 [BSD Функции Ожидания].
pid_t wait4 (pid_t pid, union wait *status`ptr, int options,
struct rusage *usage)
`sys/wait.h' (BSD): Раздел 23.8 [BSD Функции Ожидания].
pid_t wait (int *status`ptr)
`sys/wait.h' (POSIX.1): Раздел 23.6 [Завершение Процесса].
pid_t waitpid (pid_t pid, int *status`ptr, int options)
`sys/wait.h' (POSIX.1): Раздел 23.6 [Завершение Процесса].
WCHAR_MAX
`limits.h' (GNU): Раздел A.5.2 [Диапазон Типа].
wchar_t
`stddef.h' (ANSI): Раздел 18.4 [Введение в Расширенные Символы].
int WCOREDUMP (int status)
`sys/wait.h' (BSD): Раздел 23.7 [Статус Завершения Процесса].
size_t wcstombs (char *string, const wchar_t wstring, size_t size)
`stdlib.h' (ANSI): Раздел 18.5 [Расширенное Строковое Преобразование].
int wctomb (char *string, wchar_t wchar)
`stdlib.h' (ANSI): Раздел 18.7 [Преобразование Одного Символа].
int WEXITSTATUS (int status)
`sys/wait.h' (POSIX.1): Раздел 23.7 [Статус Завершения Процесса].
int WIFEXITED (int status)
`sys/wait.h' (POSIX.1): Раздел 23.7 [Статус Завершения Процесса].
int WIFSIGNALED (int status)
`sys/wait.h' (POSIX.1): Раздел 23.7 [Статус Завершения Процесса].
int WIFSTOPPED (int status)
`sys/wait.h' (POSIX.1): Раздел 23.7 [Статус Завершения Процесса].
int W_OK
`unistd.h' (POSIX.1): Раздел 9.8.8 [Прверка Прав Файла].
int wordexp (const char *words, wordexp_t *word-vector-ptr, int flags)
`wordexp.h' (POSIX.2): Раздел 16.4.2 [Вызов Wordexp].
wordexp_t
`wordexp.h' (POSIX.2): Раздел 16.4.2 [Вызов Wordexp].
void wordfree (wordexp_t *word-vector-ptr)
`wordexp.h' (POSIX.2): Раздел 16.4.2 [Вызов Wordexp].
WRDE_APPEND
`wordexp.h' (POSIX.2): Раздел 16.4.3 [Флаги для Wordexp].
WRDE_BADCHAR
`wordexp.h' (POSIX.2): Раздел 16.4.2 [Вызов Wordexp].
WRDE_BADVAL
`wordexp.h' (POSIX.2): Раздел 16.4.2 [Вызов Wordexp].
WRDE_CMDSUB
`wordexp.h' (POSIX.2): Раздел 16.4.2 [Вызов Wordexp].
WRDE_DOOFFS
`wordexp.h' (POSIX.2): Раздел 16.4.3 [Флаги для Wordexp].
WRDE_NOCMD
`wordexp.h' (POSIX.2): Раздел 16.4.3 [Флаги для Wordexp].
WRDE_NOSPACE
`wordexp.h' (POSIX.2): Раздел 16.4.2 [Вызов Wordexp].
WRDE_REUSE
`wordexp.h' (POSIX.2): Раздел 16.4.3 [Флаги для Wordexp].
WRDE_SHOWERR
`wordexp.h' (POSIX.2): Раздел 16.4.3 [Флаги для Wordexp].
WRDE_SYNTAX
`wordexp.h' (POSIX.2): Раздел 16.4.2 [Вызов Wordexp].
WRDE_UNDEF
`wordexp.h' (POSIX.2): Раздел 16.4.3 [Флаги для Wordexp].
ssize_t write (int filedes, const void *buffer, size_t size)
`unistd.h' (POSIX.1): Раздел 8.2 [Прмитивы Ввода/Вывода].
int WSTOPSIG (int status)
`sys/wait.h' (POSIX.1): Раздел 23.7 [Статус Завершения Процесса].
int WTERMSIG (int status)
`sys/wait.h' (POSIX.1): Раздел 23.7 [Статус Завершения Процесса].
int X_OK
`unistd.h' (POSIX.1): Раздел 9.8.8 [Прверка Прав Файла].
<sect> Приложение С: Сопровождение Библиотеки
<p>
<sect1> C.1 Как Установить Библиотеку GNU C
<p>
Установка библиотеки GNU C относительно проста.
Вы нуждаетесь в последней версии GNU MAKE. Изменение Библиотеки GNU
C, чтобы работать с другими программами make было бы настолько трудно, что
мы рекомендуем Вам взамен перенести GNU MAKE.
Чтобы конфигурировать библиотеку GNU C для вашей системы, выполните
команду оболочки "configure" с sh. Используйте аргумент, который является
стандартным именем GNU для конфигурации вашей системы например "sparc
sun-sunos4.1 " для Sun 4 выполняющего Sunos 4.1. См. раздел " Установка
GNU CC " в Руководстве по Использованию и Перенесению GNU CC, для полного
описания стандартных имен конфигурации GNU. Если Вы опускаете имя
конфигурации,"cofigure" пробует предположить его, анализируя систему,
на которой она выполняется. Она может и не быть способна придумать
предположение, и предположение может быть неправильно. "configure" сообщит
Вам каноническиое имя относительно выбранной конфигурации перед
продолжением.
Библиотека GNU C в настоящее время поддерживает конфигурации,
которые соответствуют следующим шаблонам:
<tscreen><verb> alpha-dec-osf1
i386-anything-bsd4.3
i386-anything-gnu
i386-anything-sco3.2
i386-anything-sco3.2v4
i386-anything-sysv
i386-anything-sysv4
i386-sequent-bsd
m68k-hp-bsd4.3
m68k-sony-newsos
m68k-sun-sunos4.n
mips-dec-ultrix4.n
sparc-sun-solaris2.n
sparc-sun-sunos4.n
decstation
hp320-bsd4.3 hp300bsd
i386-sco
i386-sco3.2v4
i386-sequent-dynix
i386-svr4
news
sun3-sunos4.n sun3
sun4-solaris2.n sun4-sunos5.n
sun4-sunos4.n sun4
`--with-gnu-ld'
`--with-gnu-as'
`--nfp'
`--prefix=directory'
`--exec-prefix=directory'
Самый простой способ выполнять выбор конфигурации состоит в том, чтобы делать это в каталоге, который содержит библиотечные источники (исходники).
Вы можете формировать библиотеку в некотором другом каталоге, перейдя в этот другой каталог, чтобы выполнить configure. В общем, чтобы выполнить выбор конфигурации, Вы должны будете определить каталог для этого, примерно так:
mkdir ../hp320
cd ../hp320
../src/configure hp320-bsd4.3
Эта возможность позволяет Вам, хранить исходники и bin-файлы в различных каталогах, и это облегчает формирование библиотеки для отдельных различных машин из того же самого набора исходников. Просто создайте каталог формирования для каждой целевой машины, и выполните configure в этом каталоге, определяя имя конфигурации целевой машины.
Библиотека имеет ряд параметров конфигурации специального назначения. Они определены в файле " Makeconfig "; см. комментарии в этом файле для подробностей.
Но не редактируйте файл " Makeconfig " непосредственно, взамен, создайте файл " configparms' в каталоге, где Вы формируете библиотеку, и определяете в этом файле параметры, которые Вы хотите определить. "Configparms" не должен быть отредактированной копией " Makeconfig "; определите только параметры, которые Вы хотите отменить!
Некоторые из машинно-зависимых программ ( часть их кода) для некоторых машин используют расширения в компиляторе GNU C, так что Вы возможно будете должны компилировать библиотеку с GCC. (Фактически, все существующие полные перенесенные версии требуют GCC.)
Текущая реализация библиотеки C содержит некоторые заглавные файлы, которые компилятор обычно обеспечивает: " stddef.h ", " stdarg.h ", и отдельные файлы с именами вида " va-machine.h ". Версии этих файлов, которые пришли с более старыми выпусками GCC, не работают правильно с библиотекой GNU C. "Stddef.h " файл в выпуске 2.2 и позже GCC правилен. Если Вы имеете выпуск 2.2 или позднее GCC, используйте версию " stddef.h " вместо версии библиотеки C. Чтобы сделать это, поместите строку " override stddef.h = " в " configparms ". Другие файлы исправлены в выпуске 2.3 и позже. "Configure" автоматически обнаружит совместимы ли установленные " stdarg.h " и " va-machine.h " файлы с библиотекой C, и использует собственные иначе.
Имеется потенциальная проблема с size_t типом и версиями GCC до выпуска 2.4. ANSI C требует, чтобы size_t всегда был тип без знака. Для совместимости с заглавными файлами существующих систем GCC определяет size_t в " stddef.h " так чтобы он мог быть любым типом, который определит " sys/types.h ". Большинство систем UNIX, которые определяют size_t в " sys/types.h ", определяют его как тип со знаком. Некоторый код в библиотеке зависит от того что size_t, - тип без знака, и не будет работать правильно, если он - со знаком.
Код библиотеки GNU C, который ожидает, что size_t будет без знака, правилен. Определение size_t как типа со знаком неправильно. Версии GCC 2.4 и позже всегда определяют size_t как тип без знака.
Тем временем, мы работаем вокруг этой проблемы, сообщая GCC явно, чтобы использовать тип без знака для size_t при компилировании библиотеки GNU C. " Configure " автоматически обнаружит то, какой тип GCC использует для size_t, чтобы отменить это в случае необходимости.
Чтобы сформировать библиотеку напечатайте make lib. Это произведет множество вывода, похожего на ошибки make (но не ошибки). Ищите сообщения об ошибках make, содержащие " *** ". Они указывают, что кое-что - действительно неправильно.
Чтобы сформировать и выполнить некоторые тестовые программы, которые осуществляют некоторые из библиотечных средств, напечатайте make test. Это произведет несколько файлов с именами подобно "program.out".
Чтобы форматировать Справочное Описание Библиотеки GNU C для печати, наберите make dvi. Для форматирования Инфо версии руководства для чтении в C-hi в Emacs или программой info, наберите make info.
Чтобы установить библиотеку, заглавные файлы, и файлы Информации руководства, наберите make install, после установки каталогов в "configparms".
Возможно в библиотеке GNU C имеются ошибки. Имеются конечно ошибки и пропуски в этом руководстве. Если Вы сообщите их, они станут фиксированными. Если Вы не сделаете этого, никто не будет когда-либо знать относительно них, и они останутся нефиксированными на всю вечность, если не дольше.
Чтобы сообщить ошибку, сначала Вы должны найти ее. Обнадеживает то, что это будет самая трудная часть. Если только вы нашли ошибку, убедитесь что это - действительно ошибка. Хороший способ сделать это состоит в том, чтобы посмотреть, ведет ли библиотека GNU C себя так же, как некоторая другая библиотека C. Если так, возможно Вы неправы, а библиотека права (но не обязательно). Если нет, одна из библиотек - возможно неправа.
Если Вы уверены, что Вы нашли ошибку, попробуете свести ее к самому маленькому тесту, который воспроизводит проблему.
Заключительный шаг, когда Вы имеете простой тест, - сообщить ошибку. При сообщении ошибки, пошлите ваш тест, результаты, которые Вы получили, результаты, которые Вы ожидали, что Вы думаете об этой проблеме (если вы думали о чем - нибудь), тип вашей системы, и версию библиотеки GNU C, которую Вы используете. Также включите файлы "config.status" и "config.make" которые созданы, при выполнении "configure"; они будут в том каталоге, который был текущий, когда Вы выполнили "configure".
Если Вы думаете, что Вы нашли некоторый способ, которым библиотека GNU C не соответствует ANSI и POSIX стандартам (см. Раздел 1.2 [Стандарты и Переносимость]. Сообщите это!
Пошлите отчет об ошибке по адресу Internet bug-glibc@prep.ai.mit.edu или через UUCP "mit-eddie!prep.ai.mit.edu!bug-glibc". Если Вы имеете другие проблемы с установкой или использованием, пожалуйста, сообщайте их также.
Если Вы не уверены, как должна вести себя функция, и это руководство не сообщает Вам, это - ошибка в руководстве. Сообщите это! Если поведение функции не сходится с руководством, то либо библиотека либо руководство имеет ошибку. Если Вы нашли любые ошибки или пропуски в этом руководстве, пожалуйста, сообщите их по адресу Internet "bug-glibc manual@prep.ai.mit.edu " или через UUCP "mit-eddie!prep.ai.mit.edu!bug-glibc-manual ".
Процесс формирования библиотеки управляется make-файлами, которые используют специальные возможности GNU MAKE. Make-файлы очень сложны, и Вы возможно не хотите попробовать понять их. Но то, что они делают довольно просто, и требует только, чтобы Вы определили несколько переменных в нужных местах.
Библиотечные исходники разделены на подкаталоги, сгруппированные по темам. Подкаталог ` string ' содержит все функции строкового манипулирования, " stdio " - все стандартные функции ввода - вывода, и т.д.
Каждый подкаталог содержит простой make-файл, называемый "Makefile", который определяет несколько переменных и тогда включает глобальный make файл "Rules" строкой подобно:
include ../Rules
subdir
headers
routines
aux
tests
others
install-lib
install-data
install
distribute
generated
extra-objs
Библиотека GNU C написана так чтобы быть легко переносимой на ряд машин и операционных систем. Машинно- и системо- зависимые функции отделены, чтобы было проще добавить реализации для новых машин или операционных систем. Этот раздел описывает размещение библиотечного исходного дерева и объясняет механизмы, используемые для выбора используемого машинно-зависимого кода.
Все машинно-зависимые и системо-зависимые файлы в библиотеке находятся в подкаталоге " sysdeps ". Этот каталог содержит иерархию подкаталогов (см. Раздел C.4.1 [Соглашения Иерархии]).
Каждый подкаталог " sysdeps " содержит исходные файлы для специфической машины или операционной системы, или для класса машин или операционных систем (например, все машины, которые используют ИИЭР 754 формат с плавающей запятой). Конфигурация определяет упорядоченный список этих подкаталогов. Каждый подкаталог неявно конкатенирует директорию предыдущего уровня к списку. Например, определение списка "unix/bsd/vax" является эквивалентным определению списка "unix/bsd/vax unix/bsd unix". Подкаталог может также определять, что он подразумевает другие подкаталоги, которые - непосредственно не выше него в иерархии каталогов. Если файл "Implies" существует в подкаталоге, он перечисляет другие подкаталоги "sysdeps", которые конкатенированы к списку, появляясь после подкаталога, содержащего "Implies" файл. Строки в "Implies" файле, которые начинаются с символа `#', игнорируются как комментарии. Например, "unix/bsd/Implies" содержит:
# BSD has Internet-related things.
unix/inet
posix
Исходный файл, как известно, является зависимым от системы наличием версии в " generic " или " stub "; каждая зависимая от системы функция должна иметь или generic или stub реализацию (нет никакого смысла в наличии обеих).
Если Вы натолкнетесь на файл который находится в одном из основных исходных каталогов (" string ", " stdio ", и т.д.), и Вы хотите к написать машинно- или системо- зависимую его версию, переместите файл в " sysdeps/generic " и запишите вашу новую реализацию в соответствующем системно-специфическом подкаталоге. Обратите внимание, что, если файл должен быть зависимым от системы, он не должен появляться в одном из основных каталогов.
Имеются несколько специальных файлов, которые могут существовать в каждом подкаталоге " sysdeps ":
`Makefile'
Каждый make-файл в подкаталоге в упорядоченном списке подкаталогов. Так как могут быть включены несколько зависимых от системы make-файлов, каждый должен быть конкатенирован к "sysdep-routines" а не просто установлен:
sysdep-routines := $(sysdep-routines) foo bar
`Subdirs'
Используйте его, когда имеются полностью новые наборы функций и заглавных файлов, которые должны войти в библиотеку. Например, "sysdeps/unix/inet/Subdirs" содержит "inet"; "inet" каталог содержит различные ориентируемые сетью операции, которые имеет смысл помещать в библиотеку на системах, которые поддерживают Internet.
`Dist'
`configure'
Для опции " - with-package=value " " configure " устанавливает переменную оболочки " with_package "; если опция - только " - with-package' (никакого аргумента), то она устанавливает " with_package" как "yes".
`configure.in'
Это - общая схема того, как изолированы зависимости системы. Следующий раздел объясняет, как решить какие каталоги в " sysdeps " использовать. Раздел C.4.2 [Перенос на UNIX], имеет некоторые советы относительно переноса библиотеки на варианты UNIX.
Имя конфигурации GNU имеет три части: CPU тип, имя изготовителя, и операционная система. " Configure " использует их, чтобы выбрать список зависимых от системы каталогов. Если " - nfp " опция не передана к "configure", каталог " machine/fpu " также используется. Операционная система часто имеет основную операционную систему; например, если операционная система - "sunos4.1", основная операционная система - "unix/bsd". Алгоритм, используемый, чтобы выбрать список каталогов прост: " configure " делает список из основной операционной системы, изготовителя, типа CPU, и операционной системой, в этом порядке. И затем конкатенирует их все вместе с наклонными чертами вправо между ними, чтобы произвести имя каталога; например, конфигурация " sparc-sun-sunos4.1" соответствует " unix/bsd/sun/sparc/sunos4.1 ". Затем " сonfigure " пробует удалять каждый элемент списка по очереди, так что " unix/bsd/sparc " и " sun/sparc " также пробуются, среди других. Так как точный номер версии операционной системы - часто не важен, и было бы очень неудобно, для примера, иметь идентичные "sunos4.1.1" и "sunos4.1.2" каталоги, ", configure " пробует менее специфические имена операционной системы, удаляя конечные суфиксы, начинающиеся с точки.
Например, вот полный список каталогов, которых бы добивалась конфигурация "sparc-sun-sunos4.1" (без опции "- nfp"):
sparc/fpu
unix/bsd/sun/sunos4.1/sparc
unix/bsd/sun/sunos4.1
unix/bsd/sun/sunos4/sparc
unix/bsd/sun/sunos4
unix/bsd/sun/sunos/sparc
unix/bsd/sun/sunos
unix/bsd/sun/sparc
unix/bsd/sun
unix/bsd/sunos4.1/sparc
unix/bsd/sunos4.1
unix/bsd/sunos4/sparc
unix/bsd/sunos4
unix/bsd/sunos/sparc
unix/bsd/sunos
unix/bsd/sparc
unix/bsd
unix/sun/sunos4.1/sparc
unix/sun/sunos4.1
unix/sun/sunos4/sparc
unix/sun/sunos4
unix/sun/sunos/sparc
unix/sun/sunos
unix/sun/sparc
unix/sun
unix/sunos4.1/sparc
unix/sunos4.1
unix/sunos4/sparc
unix/sunos4
unix/sunos/sparc
unix/sunos
unix/sparc
unix
sun/sunos4.1/sparc
sun/sunos4.1
sun/sunos4/sparc
sun/sunos4
sun/sunos/sparc
sun/sunos
sun/sparc
sun
sunos4.1/sparc
sunos4.1
sunos4/sparc
sunos4
sunos/sparc
sunos
sparc
Имеются несколько каталогов на верхнем уровне " sysdeps " иерархии, которые не архитектуры.
" generic "
" stub "
" ieee754 "
" posix "
" UNIX "
" UNIX " подразумевает " posix ". Имеются некоторые подкаталоги специального назначения " UNIX ":
" pnix/common "
И " unix/bsd " и " unix/sysv/sysv4 " подразумевают " unix/common ".
" pnix/inet "
" mach "
Большинство систем UNIX существенно похожи. Имеются небоьшие различия между различными машинами, и средствами обеспечиваемыми ядром. Но интерфейс для средств операционной системы, довольно однородный и простой.
Код для систем UNIX находится в каталоге " unix ", на верхнем уровне "sysdeps" иерархии. Этот каталог содержит подкаталоги (и деревья подкаталогов) для различных вариантов UNIX.
Функции, которые являются системными вызовами в большинстве систем UNIX, выполнены в ассемблерном коде в файлах в " sysdeps/unix ". Эти файлы именованы с суффиксом " .S "; например, " __ open.S".
Эти файлы используют набор макрокоманд, которые должны быть определены в " sysdep.h ". " Sysdep.h " файл в " sysdeps/unix " частично определяет их; " sysdep.h " файл в другом каталоге должен закончить их определение для специфической машины и варианта операционной системы. См. " sysdeps/unix/sysdep.h " и машинно-специфическую " sysdep.h " реализацию.
Системно-специфический make-файл для каталога ` unix ' (то есть файл " sysdeps/unix/Makefile ") содержит правила генерации отдельных файлов в системе UNIX, на которой Вы формируете библиотеку (которая принята как целевая система). Все сгенерированные файлы будут помещены в каталог, где сохраняются объектные файлы; они не должны воздействовать на исходное дерево непосредственно. Будут сгенерированы файлы: "ioctls.h", "errnos.h", "sys/param.h", и "errlist.c" (для " stdio " раздела библиотеки).
Почти вся библиотека была написана Роландом Мак-Гратом (Roland McGrath), за исключением некоторых дополнений, которе мы не будем здесь обсуждать.