Wireshark — одна из незаменимых утилит для «прослушки» сети, при работе с сетевыми протоколами. В состав программы уже входит некое количество диссекторов1, которое помогают детально рассмотреть пакеты базовых протоколов. Но при работе над проприетарным протоколом компании Nortel я столкнулся с отсутсвием подходящего диссектора. А нужен он был как воздух. Выход был очевиден — написать свой. Что я и сделал.Таким образом, имея небольшой опыт написания плагина «анатома» под Wireshark, я решил поделиться знаниями и опытом с сообществом. Ну и для себя записать, на случай, если в будущем понадобится.
Диссекция — лат. dissectio, от dissecare, рассекать
Примечание 1: при написании статьи я предполагал, что читатель знаком с утилитой Wireshark, а также умеет пользоваться ее базовыми возможностями.
Примечание 2: так как я работаю под Linux, то и плагин писал под эту ОС. Под Windows мой плагин тоже должен собираться. Отличия, я думаю, будут только в make файлах.
Примечание 3: так как протокол, над которым я работал, проприетарный и закрытый, а так же из-за миллиона соглашений о неразглашении, в данной статье я рассматриваю свой, придуманный, протокол.
Протокол Foo
В двух словах я опишу придуманный протокол, который назову незамысловатым именем Foo. Пусть этот протокол будет над протоколом UDP и будет иметь следующую структуру:
- 1 байт — версия протокола
- 1 байт — тип пакета
- 1 байт — всевозможные флаги
- 1 байт — какая-то булева переменная
- 4 байт — длина полезной нагрузки
- От 0 до 200 байт — полезная нагрузка
Настройка окружения
Перед тем как начать писать плагин, необходимо что-то поставить, что-то создать, где-то что-то изменить. Вот что Wireshark просит установить:
- python (думаю любой 2-ой версии, но точно не 3-ей)
- cmake
- bison
- flex
После установки всего необходимого качаем исходники Wireshark той версии, для которой будем писать плагин. В моем случае исходники стабильной ветки 1.6:
$ cd $HOME
$ svn co http://buildbot.wireshark.org/trunk-1.6/ wiresharkЧтобы убедиться в работоспособности компиляции, а так же в том, что все необходимые утилиты и библиотеки установлены, запустите:
$ cd wireshark
$ ./autogen.sh
$ ./configureЕсли все в порядке, то переходим в папку plugins и создаем там свою папку с названием протокола:
$ cd $HOME/wireshark/plugins
$ mkdir foo
$ cd foo
$ touch packet-foo.cКаркас
Тут мне хотелось бы для начала выделить каркас плагина, ту его основную часть, которой будет достаточно для того, чтобы Wireshark «подхватил» плагин.
packet-foo.c
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include <epan/packet.h>
#define FOO_PORT 35000
/* Номер UDP порта, на котором мы предполагаем будет находится FOO траффик. */
static int proto_foo = -1;
/* При регистрации протокола переменная затрется идентификатором протокола. */
void proto_register_foo(void)
{
proto_foo = proto_register_protocol (
"FOO Protocol", /* полное имя */
"FOO", /* короткое имя */
"foo" /* аббревиатура */
);
}В самом начале мы вызываем функцию proto_register_protocol(), которая регистрирует протокол и выдает его уникальный идентификатор. Функции мы передаем три разных имени нашего протокола, которые будут выводится в различных частях программы. (К примеру, имена «FOO Protocol» и «FOO» используются в Настройках Wireshark’а, а аббревиатура «foo» используется в поле фильтра.)
Далее нам нужно назначить функцию, которая будет вызываться в случае необходимости расшифровать пойманный foo-пакет. Делается это вызовом функции create_dissector_handle().
void proto_reg_handoff_foo(void)
{
static dissector_handle_t foo_handle;
foo_handle = create_dissector_handle(dissect_foo, proto_foo);
dissector_add_uint("udp.port", FOO_PORT, foo_handle);
}Тут мы регистрируем обработчик-диссектор, который выполняет “грязную” работу разложения протокола по составу и привязываем его к протоколу proto_foo. Затем мы связываем наш обработчик с UDP портом, на котором мы предполагаем будет ходить трафик. Таким образом Wireshark вызовет “нас”, когда на заданном нами порту (35000) появится какая-то активность.
Есть соглашение, согласно которому фукнции proto_register_foo() и proto_reg_handoff_foo() необходимо написать в конце нашего исходного файла.
Теперь осталось самое главное — написать сам код диссектора.
static void dissect_foo(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
col_set_str(pinfo->cinfo, COL_PROTOCOL, "FOO");
col_clear(pinfo->cinfo, COL_INFO);
}Эта функция будет вызываться для детальной работы над пакетом, который ей передан. Данные пакета хранятся в специальном буфере — tvb. В pinfo кладем общую информацию о протоколе. А в tree происходят основные изменения, когда определяется конечный вид протокола в выводе Wireshark'а.
В первой строке мы устанавливаем значение в колонку Protocol. Во второй — очищаем Info колонку. (Обе колонки как правило показываются во время захвата пакетов.)
Всё, на данный момент есть минимум кода для того чтобы можно было смело собирать наш плагин и загружать его в Wireshark.
Сборка плагина
Для сборки (под Linux) нам необходимо обзавестись некоторыми файлами в нашей директории: Makefile.am, Makefile.common и moduleinfo.h.
- Makefile.am — UNIX/Linux make файл
- Makefile.common — общий make файл для UNIX/Linux и Windows, содержит имена файлов плагина
- Makefile.nmake — make файл для Windows
- moduleinfo.h — содержит версию плагина
- moduleinfo.nmake — содержит информацию о версиях DLL для Windows
- packet-foo.c — наш исходный код для диссектора
set(DISSECTOR_SRC
packet-foo.c
)
set(PLUGIN_FILES
plugin.c
${DISSECTOR_SRC}
)
set(CLEAN_FILES
${PLUGIN_FILES}
)
if (WERROR)
set_source_files_properties(
${CLEAN_FILES}
PROPERTIES
COMPILE_FLAGS -Werror
)
endif()
include_directories(${CMAKE_CURRENT_SOURCE_DIR})
register_dissector_files(plugin.c
plugin
${DISSECTOR_SRC}
)
add_library(foo ${LINK_MODE_MODULE}
${PLUGIN_FILES}
)
set_target_properties(foo PROPERTIES PREFIX "")
set_target_properties(foo PROPERTIES LINK_FLAGS "${WS_LINK_FLAGS}")
target_link_libraries(foo epan)
install(TARGETS foo
LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}/@CPACK_PACKAGE_NAME@/plugins/${CPACK_PACKAGE_VERSION} NAMELINK_SKIP
RUNTIME DESTINATION ${CMAKE_INSTALL_LIBDIR}/@CPACK_PACKAGE_NAME@/plugins/${CPACK_PACKAGE_VERSION}
ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}/@CPACK_PACKAGE_NAME@/plugins/${CPACK_PACKAGE_VERSION}
)Примечание: можно не запоминать каждый раз, как выглядит CMakeLists.txt файл, а скопировать его из папки любого существующего плагина, к примеру, interlink. И затем заменить все упоминания interlink в этом файле на foo.
Затем даем знать о нашем плагине тулзам автоматизации процесса сборки.
$ cd $HOME/wireshark/
$ vim CMakeLists.txtДобавляем строчку «plugins/foo» учитывая отступы:
.......
if(ENABLE_PLUGINS)
set(HAVE_PLUGINS 1)
set(PLUGIN_DIR="${DATAFILE_DIR}/plugins/${CPACK_PACKAGE_VERSION}")
set(PLUGIN_SRC_DIRS
plugins/foo
plugins/asn1
plugins/docsis
.......Теперь создаем директорию, в которой будут храниться созданные во время компиляции и линковки файлы. Следом запускаем сам процесс сборки. Следующие шаги выполняем из директории $HOME/wireshark/
$ mkdir build
$ cd build
$ cmake ..
$ make fooПри успешной компиляции мы получим foo.so библиотеку в папке $HOME/wireshark/build/lib/.
Тестовый запуск
Копируем файл foo.so в дирекуторию /usr/lib/wireshark/plugins/1.6.0/ и запускаем Wireshark. Заходим в «Help -> About Wireshark», переходим на вкладку Plugins и в появившемся списке находим наш плагин — foo.so.
Чтобы удостовериться, что плагин распознает наш протокол, стартуем захват пакетов и пускаем по сети пакеты с нашим протоколом. (Для примера я на скорую руку написал программку, которая посылает по сети UDP пакет FOO протокола. Ее код можно найти в конце статьи.)
Рабочий диссектор
Теперь, когда у нас есть каркас плагина, который пока ничего полезного для нас не делает, но как минимум запускается, мы «распишем» ему наш протокол. Самая простая вещь, которую мы можем сделать — определить границы нашего протокола.
Для этого, в первую очередь, мы создаем ветку на нашем дереве (tree), в которую будем помещать результаты декодирования. Диссектор вызывается в двух различных случаях: в одном случае, когда необходимо получить сводную информацию о пакете, и в другом случае, когда нужно вывести детальную информацию о том же пакете. Если указатель на tree равен NULL, значит у нас запрашивают только сводную информацию. Иначе нам предлагается заполнить tree детальной информацией, которая будет выведена пользователю Wireshark. С учетом этого наш диссектор приобретает вид:
static void dissect_foo(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
col_set_str(pinfo->cinfo, COL_PROTOCOL, "FOO");
col_clear(pinfo->cinfo, COL_INFO);
if (tree) {
proto_item *ti = NULL;
ti = proto_tree_add_item(tree, proto_foo, tvb, 0, -1, FALSE);
}
}Здесь мы добавили ветку в дерево (tree) вызовом proto_tree_add_item(). Эта ветка будет содержать все детали о нашем foo протоколе. Так же мы помечаем область данных в пакете, которую использует наш протокол. В нашем случае — это вся область за границей данных UDP пакета, так как мы не рассматриваем случай, когда за нашим протоколом содержится еще один.
Параметры функции proto_tree_add_item():
- tree — все дерево информации о нашем пакете
- proto_foo — идентификатор нашего протокола
- tvb — блок данных (данные, переданные нашим протоколом)
- 0 — указываем, начиная с какой позиции данные в блоке tvb являются данными нашего foo протокола
- -1 — количество байт, занимаемое нашим протоколом ("-1" означает «до конца блока данных»)
- FALSE — указывается порядок байт (TRUE — если байты расположены в сетевом порядке.)
Следующим шагом будет добавление деталей. Для этого шага потребуется создание нескольких массивов и дополнительных вызовов функций, который помогут при расшифровке. Изменения коснутся тела функции proto_register_foo(), показанной ранее.
Добавим два статических массива в начало proto_register_foo(). Потом зарегистрируем эти массивы после вызова функции proto_register_protocol().
void proto_register_foo(void)
{
static hf_register_info hf[] = {
{ &hf_foo_hdr_version,
{ "FOO Header Version", "foo.hdr.version",
FT_UINT8, BASE_DEC,
NULL, 0x0,
NULL, HFILL }
},
{ &hf_foo_hdr_type,
{ "FOO Header Type", "foo.hdr.type",
FT_UINT8, BASE_DEC,
NULL, 0x0,
NULL, HFILL }
}
};
static gint *ett[] = { &ett_foo };
proto_foo = proto_register_protocol (
"FOO Protocol",
"FOO",
"foo" );
proto_register_field_array(proto_foo, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
}А сразу после объявления глобальной переменной proto_foo добавим еще 3 объявления:
static gint ett_foo = -1;
static int hf_foo_hdr_version = -1;
static int hf_foo_hdr_type = -1;Теперь улучшим отображение нашего протокола:
if (tree) {
proto_item *ti = NULL;
proto_tree *foo_tree = NULL;
ti = proto_tree_add_item(tree, proto_foo, tvb, 0, -1, FALSE);
foo_tree = proto_item_add_subtree(ti, ett_foo);
proto_tree_add_item(foo_tree, hf_foo_hdr_version, tvb, 0, 1, FALSE);
proto_tree_add_item(foo_tree, hf_foo_hdr_type, tvb, 1, 1, FALSE);
}Теперь знания Wireshark о нашем протоколе становятся более детальными. Пока мы лишь распознали первые 2 байта нашего foo протокола, которые отвечают за версию протокола и тип пакета соответственно.
Вызов функции proto_item_add_subtree() добавил дополнительную ветвь (foo_tree) с деталями о foo протоколе в дерево (tree) информации о всем пришедшем пакете. В foo_tree мы будет детально описывать наш протокол.
Переменной ett_foo контролируется “развертка” (expansion) дерева информации о протоколе в выводе программы Wireshark. Эта переменная запоминает, должен ли наш протокол быть развернутым в то время, пока мы передвигаемся по пакетам.
proto_tree_add_item() на этот раз использует переменную hf_foo_hdr_version для вывода значения в нужном формате. hdr_version — 1 байт из tvb, начиная с позиции 0. hdr_type — 1 байт из tvb, начиная с позиции 1.
Если мы посмотрим на объявление hf_foo_hdr_version в статическом массиве, то увидим детально описанное поле, где
- hf_foo_hdr_version — индекс ветки
- FOO Header Version — именование поля
- foo.hdr.version — это строчка, используемая для фильтрации пакетов (такой вид строчки будет в поле фильтра)
- FT_UNIT8 — указывает на тип и размер элемента, который мы читаем из блока данных tvb. В данном случае указывает, что поле «версия протокола» занимает 1 байт типа unsigned integer. (Другие возможные типы можно найти в файле wireshark/epan/ftypes/ftypes.h)
- BASE_DEC — для числовых типов указывае, т в какой системе выводить числа. (Также может быть BASE_HEX или BASE_OCT. Для нечисловых типов используем BASE_NONE.)
Теперь можно снова собрать плагин и запустить его вместе с Wireshark. Мы увидим, что вывод Wireshark'а стал более пригодным.
Чтож, завершим работу по расшифровке нашего foo-протокола. Для этого нам понадобится объявить еще несколько глобальных переменных и сделать несколько дополнительных вызовов:
...
static int hf_foo_hdr_flags = -1;
static int hf_foo_hdr_bool = -1;
static int hf_foo_pl_len = -1;
static int hf_foo_payload = -1;
...
void proto_register_foo(void)
{
...
{ &hf_foo_hdr_flags,
{ "FOO Header Flags", "foo.hdr.flags",
FT_UINT8, BASE_HEX,
NULL, 0x0,
NULL, HFILL }
},
{ &hf_foo_hdr_bool,
{ "FOO Header Boolean", "foo.hdr.bool",
FT_BOOLEAN, BASE_NONE,
NULL, 0x0,
NULL, HFILL }
},
{ &hf_foo_pl_len,
{ "FOO Payload Length", "foo.pl_len",
FT_UINT8, BASE_DEC,
NULL, 0x0,
NULL, HFILL }
},
{ &hf_foo_payload,
{ "FOO Payload", "foo.payload",
FT_STRING, BASE_NONE,
NULL, 0x0,
NULL, HFILL }
}
...
}
static void dissect_foo(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
...
if (tree) {
gint offset = 0;
proto_item *ti = NULL;
proto_tree *foo_tree = NULL;
ti = proto_tree_add_item(tree, proto_foo, tvb, 0, -1, FALSE);
foo_tree = proto_item_add_subtree(ti, ett_foo);
proto_tree_add_item(foo_tree, hf_foo_hdr_version, tvb, offset, 1, FALSE); offset += 1;
proto_tree_add_item(foo_tree, hf_foo_hdr_type, tvb, offset, 1, FALSE); offset += 1;
proto_tree_add_item(foo_tree, hf_foo_hdr_flags, tvb, offset, 1, FALSE); offset += 1;
proto_tree_add_item(foo_tree, hf_foo_hdr_bool, tvb, offset, 1, FALSE); offset += 1;
proto_tree_add_item(foo_tree, hf_foo_pl_len, tvb, offset, 4, TRUE); offset += 4;
proto_tree_add_item(foo_tree, hf_foo_payload, tvb, offset, -1, FALSE);
}
}
Таким образом мы расшифровали все биты нашего придуманного протокола.
Можно видеть различные типы элементов, которые мы использовали во время расшифровки: FT_BOOLEAN, FT_STRING и FT_UINT8. А так же, в случае с нечисловыми элементами, использовали BASE_NONE.
Теперь Wireshark имеет достаточно хорошее представление о нашем протоколе. И на этом шаге можно было бы остановиться, если бы такой детализации хватало всегда. У нас пока еще есть поле flags, которое придется раскладывать побитово вручную. А также, в случае, если версия протокола неизвестна, можно ли доверять выводу? Ну и самый важный момент — диссектор будет генерировать исключение, если пакет придет без поля payload и с нулевым значением pl_len. Итак, есть место для совершенствования плагина. Продолжим…
Добавляем деталей в вывод
Совершенству нет предела! Так и в нашем случае. Начем с именования версии и типа пришедшего пакета, что позволит гораздо быстрее воспринимать информацию при просмотре пакета. Для этого нам потребуются два массива:
static const value_string packetversions[] = {
{ 1, "Version 1" },
{ 0, NULL }
};
static const value_string packettypes[] = {
{ 1, "Ping request" },
{ 2, "Ping acknowledgment" },
{ 3, "Print payload" },
{ 0, NULL }
};Зависимость в массивах очень простая — «значение, имя значния». Таким образом, при просмотре пакета мы будем видеть не голый номер типа пакета и вспоминать, что он значит, а сразу увидим описание типа. Для доступа к этим массивам будем использовать VALS-макросы, которые предоставляются самим Wireshark.
{ &hf_foo_hdr_version,
{ "FOO Header Version", "foo.hdr.version",
FT_UINT8, BASE_DEC,
VALS(packetversions), 0x0,
NULL, HFILL }
},
{ &hf_foo_hdr_type,
{ "FOO Header Type", "foo.hdr.type",
FT_UINT8, BASE_DEC,
VALS(packettypes), 0x0,
NULL, HFILL }
}С версией и типом пакета мы определились. Теперь более детально распишем флаги.
#define FOO_FIRST_FLAG 0x01
#define FOO_SECOND_FLAG 0x02
#define FOO_ONEMORE_FLAG 0x04
static int hf_foo_flags_first = -1;
static int hf_foo_flags_second = -1;
static int hf_foo_flags_onemore = -1;
void proto_register_foo(void) {
...
{ &hf_foo_flags_first,
{ "FOO first flag", "foo.hdr.flags.first",
FT_BOOLEAN, FT_INT8,
NULL, FOO_FIRST_FLAG,
NULL, HFILL }
},
{ &hf_foo_flags_second,
{ "FOO second flag", "foo.hdr.flags.second",
FT_BOOLEAN, FT_INT8,
NULL, FOO_SECOND_FLAG,
NULL, HFILL }
},
{ &hf_foo_flags_onemore,
{ "FOO onemore flag", "foo.hdr.flags.onemore",
FT_BOOLEAN, FT_INT8,
NULL, FOO_ONEMORE_FLAG,
NULL, HFILL }
}
...
}
static void dissect_foo(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) {
...
proto_tree_add_item(foo_tree, hf_foo_hdr_flags, tvb, offset, 1, FALSE);
proto_tree_add_item(foo_tree, hf_foo_flags_first, tvb, offset, 1, FALSE);
proto_tree_add_item(foo_tree, hf_foo_flags_second, tvb, offset, 1, FALSE);
proto_tree_add_item(foo_tree, hf_foo_flags_onemore, tvb, offset, 1, FALSE); offset += 1;
...
}Так как флаг — это один бит информации со значениями «1» или «0», то мы используем тип FT_BOOLEAN. Также мы задаем маску для каждого флага шестым параметром (FOO_FIRST_FLAG, FOO_SECOND_FLAG, FOO_ONEMORE_FLAG), чтобы определить, какой бит из байта интерпретировать. Обратите внимание на то, что мы используем одно и то же значение переменной offset для всех флагов.
Вывод теперь гораздо читабельнее. Но мы не остановимся и сделам его еще более информативным. Обратите внимание: Wireshark именует пакеты как «FOO Protocol». Это имя мы задали при регистрации протокола. Wireshark предоставляет возможность добавить дополнительную ифнормацию к этому имени. Выведем в этом поле информацию о типе протокола. Для этого нам понадобиться получить значение типа, используя tvb_get_guint8()2. Полученное значение выведем в двух местах: сразу за именем протокола и в колонке Info.
static void dissect_foo(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
guint8 packet_version = tvb_get_guint8(tvb, 0);
guint8 packet_type = tvb_get_guint8(tvb, 1);
guint32 packet_pl_len = 0;
col_set_str(pinfo->cinfo, COL_PROTOCOL, "FOO");
col_clear(pinfo->cinfo, COL_INFO);
if (tree) {
gint offset = 0;
proto_item *ti = NULL;
proto_tree *foo_tree = NULL;
ti = proto_tree_add_item(tree, proto_foo, tvb, 0, -1, FALSE);
foo_tree = proto_item_add_subtree(ti, ett_foo);
proto_tree_add_item(foo_tree, hf_foo_hdr_version, tvb, offset, 1, FALSE); offset += 1;
switch ( packet_version ) {
case 1:
col_add_fstr(pinfo->cinfo, COL_INFO, "Type: %s",
val_to_str(packet_type, packettypes, "Unknown (0x%02x)"));
proto_item_append_text(ti, ", Type: %s",
val_to_str(packet_type, packettypes, "Unknown (0x%02x)"));
proto_tree_add_item(foo_tree, hf_foo_hdr_type, tvb, offset, 1, FALSE); offset += 1;
proto_tree_add_item(foo_tree, hf_foo_hdr_flags, tvb, offset, 1, FALSE);
proto_tree_add_item(foo_tree, hf_foo_flags_first, tvb, offset, 1, FALSE);
proto_tree_add_item(foo_tree, hf_foo_flags_second, tvb, offset, 1, FALSE);
proto_tree_add_item(foo_tree, hf_foo_flags_onemore, tvb, offset, 1, FALSE); offset += 1;
proto_tree_add_item(foo_tree, hf_foo_hdr_bool, tvb, offset, 1, FALSE); offset += 1;
proto_tree_add_item(foo_tree, hf_foo_pl_len, tvb, offset, 4, TRUE);
packet_pl_len = tvb_get_ntohl(tvb, offset); offset += 4;
if ( packet_pl_len )
proto_tree_add_item(foo_tree, hf_foo_payload, tvb, offset, -1, FALSE);
break;
default:
col_add_fstr(pinfo->cinfo, COL_INFO, "Unknown version of Foo protocol (0x%02x)", packet_version);
}
}
}Полученное значние мы передаем макросу val_to_str(), который для переданного значения возвращает строку-описание, либо заданную нами строку, в случае, если описание не найдено.
Так же мы пофиксили ошибку при неправильной обработке payload, когда выбрасывалось исключение.
И в дополнение добавили ветвление для разных версий протокола.
Дополнение
Пример рабочего диссектора для протокола Foo
tvb_get_guint8()
Помимо функции tvb_get_guint8() имеется ряд других, описание которых можно найти в файле wireshark/epan/tvbuff.hАрхив
Архив с рабочими исходными файлами. Включает:- packet-foo.c — исходный код плагина диссектора
- CMakeLists.txt — cmake файл для плагина
- send-foo-packet.c — исходных код программы посылающей foo-пакет
Листинг программы посылающей foo пакет на порт 35000 *
#include <arpa/inet.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#define FOO_PORT 35000
#define BUFFER_SIZE 210
struct _message {
unsigned char pck_version; // = argv[1]
unsigned char pck_type; // = 1 | 3
unsigned char pck_flags; // = rand
unsigned char pck_boolean; // = rand
unsigned int pck_payload_len; // = strlen(argv[2])
};
int main(int argc, char ** argv) {
if ( argc != 3 ) {
printf("Usage: %s <version> <ping|\"text\">\n", argv[0]);
return 1;
}
struct sockaddr_in cli_addr;
int s, cli_len = sizeof(cli_addr);
char buf[BUFFER_SIZE];
struct _message msg;
msg.pck_version = atoi(argv[1]);
msg.pck_payload_len = 0;
unsigned int randomData = open("/dev/urandom", O_RDONLY);
unsigned int myRandomInteger;
read(randomData, &myRandomInteger, sizeof(myRandomInteger));
msg.pck_flags |= myRandomInteger%8;
read(randomData, &myRandomInteger, sizeof(myRandomInteger));
msg.pck_boolean = myRandomInteger%2;
close(randomData);
if ( (s=socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) == -1 ) {
perror("socket");
exit(1);
}
memset((char*)&cli_addr, 0, sizeof(cli_addr));
cli_addr.sin_family = AF_INET;
cli_addr.sin_port = htons(FOO_PORT);
cli_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
memset(buf, 0, BUFFER_SIZE);
if ( ! strcmp(argv[2], "ping") ) {
msg.pck_type = 1;
} else {
msg.pck_type = 3;
msg.pck_payload_len = (strlen(argv[2])<200)?strlen(argv[2]):200;
strncpy(buf+sizeof(struct _message), argv[2], (strlen(argv[2])<200)?strlen(argv[2]):199);
}
memcpy(buf, (char*)&msg, sizeof(struct _message));
if ( sendto(s, buf, sizeof(struct _message)+msg.pck_payload_len,
0, (struct sockaddr*)&cli_addr, cli_len) == -1 ) {
perror("sendto");
exit(1);
}
exit(0);
}* программа без защиты от дурака