Подключение розетки к автомату: Подключение розетки к автомату в щитке

Понравился материал? поделись им.

Jelektrik.By

Статьи

Защита

11 октября 2021

Добавить комментарий

Соединение

.

Какая машина фактически закрывает сокет TCP и почему?

Я работаю над приложением C#, обрабатывающим сокеты TCP.

У меня есть серверное приложение (Hercules) на удаленной машине, пытающееся держать сокет открытым.
У меня есть приложение на моей машине, подписанное на этот открытый сокет.

Я использую Microsoft TCPViewer, чтобы следить за тем, что происходит.

Через несколько минут я вижу, как сокет переходит из установленного состояния в состояние ожидания по времени, а затем соединение с сокетом обрывается.

Я искал в средстве просмотра событий обоих компьютеров событие с идентификатором 4227 во всех основных местах (Журналы Windows/Приложения, /Безопасность, /Настройка, /Система и /Переадресованные события), но ничего не нашел.

Что мне делать, чтобы узнать, какая машина на самом деле закрывает сокет TCP и почему?

• tcp
• соединение
• журнал событий Windows
• сокет

6

Что мне делать, чтобы узнать, какая машина на самом деле закрывает TCP-сокет

Для того, чтобы узнать, какая сторона закрывает соединение, необходимо выполнить захват пакетов. См. https://wiki.wireshark.org/TCP-4-times-close.md, как выглядит закрытие соединения в Wireshark. Сторона, отправившая начальный FIN, закрыла соединение.

… и почему?

Этого нельзя сказать, просто взглянув на трафик. Соединение может быть закрыто, потому что протокол прикладного уровня ожидает или позволяет это сделать. Он может быть закрыт из-за сбоя клиента или сервера. Он может быть закрыт стороной из-за нарушения протокола, т.е. если другая сторона ведет себя не так, как ожидалось… Так что для того, чтобы выяснить причину, вам нужно понять протокол приложения, посмотреть лог-файлы, проверить, нет ли запущены процессы и т.д.

2

Зарегистрируйтесь или войдите в систему

Зарегистрируйтесь с помощью Google

Зарегистрироваться через Facebook

Зарегистрируйтесь, используя электронную почту и пароль

Опубликовать как гость

Электронная почта

Требуется, но никогда не отображается

Опубликовать как гость

Электронная почта

Требуется, но не отображается

Нажимая «Опубликовать свой ответ», вы соглашаетесь с нашими условиями обслуживания, политикой конфиденциальности и политикой использования файлов cookie

.

Программирование сетевых сокетов — документация Idris 1.3.3

API сокетов POSIX поддерживает связь между процессами через
сеть. Сокет представляет конечную точку сетевого взаимодействия и может быть
в одном из нескольких состояний:

• Готов , исходное состояние
• Связанный , что означает, что он был привязан к адресу, готовому для входящих
  соединения
• Прослушивание , что означает прослушивание входящих соединений
• Open , что означает готовность к отправке и приему данных;
• Закрыт , что означает, что он больше не активен.

На следующей диаграмме показано, как операции, предоставляемые API, изменяют
состояние, где Готово — начальное состояние:

Если соединение Открыто , то мы также можем отправить сообщения на
другой конец соединения и recv сообщений от него.

Пакет contrib содержит модуль Network.Socket , который
предоставляет примитивы для создания сокетов и отправки и получения
Сообщения. Он включает в себя следующие функции:

 bind : (sock : Socket) -> (addr : Maybe SocketAddress) -> (port : Port) -> IO Int
connect : (sock : Socket) -> (addr : SocketAddress) -> (port : Port) -> IO ResultCode
слушать: (носок: сокет) -> IO Int
accept: (sock: Socket) -> IO (либо SocketError (Socket, SocketAddress))
send : (sock : Socket) -> (msg : String) -> IO (либо код результата SocketError)
recv : (sock : Socket) -> (len : ByteLength) -> IO (либо SocketError (String, ResultCode))
закрыть: сокет -> ввод-вывод ()
 

Эти функции охватывают переходы состояний на диаграмме выше, но
никто из них не объясняет, как операции влияют на состояние! Это прекрасно
можно, например, попытаться отправить сообщение на сокет, который
еще не готов, или попытаться получить сообщение после закрытия сокета.

Используя ST , мы можем предоставить лучший API, который точно объясняет, как
каждая операция влияет на состояние соединения. В этом разделе мы
определить API сокетов, а затем использовать его для реализации «эхо-сервера», который
отвечает на запросы от клиента, возвращая одно отправленное сообщение
клиентом.

Определение интерфейса

Sockets

Вместо использования IO для низкоуровневого программирования сокетов мы реализуем
интерфейс с использованием ST , который точно описывает, как каждая операция
влияет на состояние сокетов и описывает, когда сокеты создаются
и удалено. Мы начнем с создания типа для описания абстрактного состояния.
сокета:

 data SocketState = Ready | Связанный | Прослушивание | Открыть | Закрыто
 

Затем мы начнем определять интерфейс, начиная с Носок тип
для представления сокетов, параметризованных их текущим состоянием:

 interface Sockets (m : Type -> Type), где
  Носок: SocketState -> Тип
 

Сокеты создаем методом socket . SocketType определен
библиотекой сокетов и описывает, является ли сокет TCP, UDP,
или какая-то другая форма. Мы будем использовать Stream для этого повсюду, что указывает на
TCP-сокет.

 сокет: SocketType -> ST m (либо () Var) [addIfRight (Sock Ready)]
 

Помните, что addIfRight добавляет ресурс, если результат операции
имеет вид Right val . По соглашению в этом интерфейсе мы будем использовать
Либо для операций, которые могут потерпеть неудачу, независимо от того, могут ли они выполняться
любую дополнительную информацию об ошибке, чтобы мы могли последовательно
используйте addIfRight и некоторые другие функции уровня типа.

Чтобы определить сервер, после того, как мы создали сокет, нам нужно связать его
в порт. Мы можем сделать это с помощью bind метод:

 bind : (sock: Var) -> (addr: возможно, SocketAddress) -> (port: Port) ->
       ST m (либо () ()) [sock ::: Sock Ready :-> (Sock Closed `или` Sock Bound)]
 

Привязка сокета может завершиться ошибкой, например, если сокет уже существует
привязан к данному порту, поэтому он снова возвращает значение типа или .
Действие здесь использует функцию уровня типа или и говорит, что:

• 0073 Носок закрыт состояние
• Если bind завершается успешно, сокет переходит в состояние Sock Bound , как
  показано на схеме выше

или реализуется следующим образом:

 или : a -> a -> либо b c -> a
или x y = либо (const x) (const y)
 

Таким образом, тип bind может быть эквивалентно записан как:

 bind : (sock : Var) -> (addr : Maybe SocketAddress) -> (port : Port) ->
       STrans m (Или () ()) [носок ::: Носок готов]
                    (либо [sock ::: Sock Closed] [sock ::: Sock Bound])
 

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

Как только мы привязали сокет к порту, мы можем начать слушать подключения
от клиентов:

 слушать : (sock : Var) ->
         ST m (Either () ()) [sock ::: Sock Bound :-> (Sock Closed `или` Sock Listening)]
 

Сокет в состоянии Listening готов принимать соединения от
индивидуальные клиенты:

 принять : (носок : Var) ->
         ST m (Либо () Var)
              [sock ::: Sock Listening, addIfRight (Sock Open)]
 

Если есть входящее соединение от клиента, принять добавляет новый
ресурс в конец списка ресурсов (по соглашению рекомендуется
добавить ресурсы в конец списка, потому что это работает более аккуратно
с обновить с , как обсуждалось в предыдущем разделе). Итак, мы сейчас
иметь два сокета : один продолжает прослушивать входящие соединения,
и один готов к общению с клиентом.

Нам также нужны методы для отправки и получения данных на сокете:

 send : (sock : Var) -> String ->
       ST m (Или () ()) [sock ::: Sock Open :-> (Sock Closed `или` Sock Open)]
recv : (носок : Var) ->
       ST m (либо () строка) [sock ::: Sock Open :-> (Sock Closed `или` Sock Open)]
 

Как только мы закончим общение с другой машиной через сокет, мы
хочу закрыть соединение и удалить сокет:

 close : (sock : Var) ->
        {auto prf : CloseOK st} -> ST m () [sock ::: Sock st :-> Sock Closed]
удалить : (носок : Var) ->
         ST m () [Удалить носок (Sock Closed)]
 

У нас есть предикат CloseOK , используемый close в неявном доказательстве
аргумент, который описывает, когда можно закрыть сокет:

 data CloseOK : SocketState -> Type where
     ЗакрытьОткрыть : ЗакрытьОК Открыть
     CloseListening : CloseOK Прослушивание
 

То есть мы можем закрыть сокет Открыть , разговаривая с другой машиной,
что приводит к прекращению связи. Мы также можем закрыть сокет, который
is Прослушивание для входящих соединений, что приводит к остановке сервера
прием запросов.

В этом разделе мы реализуем сервер, но для полноты картины мы можем
также хочу, чтобы клиент подключался к серверу на другом компьютере. Мы можем
это с connect :

 connect: (sock: Var) -> SocketAddress -> Port ->
          ST m (Или () ()) [sock ::: Sock Ready :-> (Sock Closed `или` Sock Open)]
 

Для справки, вот полный интерфейс:

 Интерфейс Сокеты (m : Тип -> Тип), где
  Носок: SocketState -> Тип
  socket : SocketType -> ST m (Ither () Var) [addIfRight (Sock Ready)]
  bind: (sock: Var) -> (addr: возможно, SocketAddress) -> (port: Port) ->
         ST m (либо () ()) [sock ::: Sock Ready :-> (Sock Closed `или` Sock Bound)]
  слушать : (носок : Вар) ->
           ST m (Either () ()) [sock ::: Sock Bound :-> (Sock Closed `или` Sock Listening)]
  принять : (носок : Var) ->
           ST m (Either () Var) [sock ::: Sock Listening, addIfRight (Sock Open)]
  connect: (sock: Var) -> SocketAddress -> Port ->
            ST m (Или () ()) [sock ::: Sock Ready :-> (Sock Closed `или` Sock Open)]
  close : (sock : Var) -> {auto prf : CloseOK st} ->
          ST m() [носок ::: Носок st :-> Носок Закрыт]
  remove : (sock : Var) -> ST m () [Удалить носок (Sock Closed)]
  отправить: (носок: Var) -> строка ->
         ST m (Или () ()) [sock ::: Sock Open :-> (Sock Closed `или` Sock Open)]
  recv : (носок : Var) ->
         ST m (либо () строка) [sock ::: Sock Open :-> (Sock Closed `или` Sock Open)]
 

Вскоре мы увидим, как это реализовать; в основном методы могут быть реализованы
в IO , напрямую используя API необработанных сокетов. Хотя сначала посмотрим
как использовать API для реализации «эхо-сервера».

Внедрение «эхо-сервера» с

сокетами

На верхнем уровне наш эхо-сервер начинается и заканчивается без доступных ресурсов,
и использует интерфейсы ConsoleIO и Sockets :

 startServer : (ConsoleIO m, Sockets m) => ST m () []
 

Первым делом нам нужно создать сокет для привязки к порту
и прослушивание входящих соединений с использованием сокета . Это может потерпеть неудачу,
поэтому нам нужно иметь дело со случаем, когда он возвращает Right sock , где
sock — это новая переменная сокета или где она возвращает Left err :

 startServer : (ConsoleIO m, Sockets m) => ST m () []
стартовый сервер =
  do Right sock <- socket Stream
           | Левая ошибка => чистая ()
     ?что теперь
 

Рекомендуется реализовать эту функцию интерактивно, шаг за шагом.
шаг, используя отверстия, чтобы увидеть, в каком состоянии находится вся система после каждого
шаг. Здесь мы видим, что после успешного вызова сокета мы
иметь доступный сокет в состоянии Ready :

 sock : Var
  m : Тип -> Тип
  ограничение: ConsoleIO m
  ограничение1 : Сокеты m
--------------------------------------
whatNow : STrans m () [sock ::: Sock Ready] (\result1 => [])
 

Далее нам нужно привязать сокет к порту и начать слушать
связи. Опять же, каждый из них может выйти из строя. Если да, мы удалим
розетка. Сбой всегда приводит к тому, что сокет находится в состоянии Closed ,
поэтому все, что мы можем сделать, это удалить it:

 startServer : (ConsoleIO m, Sockets m) => ST m () []
стартовый сервер =
  do Right sock <- socket Stream | Левая ошибка => чистая ()
     Правильно ок <- привязать носок Ничего 9442 | Левая ошибка => удалить носок
     Правильно ок <- слушать носок | Левая ошибка => удалить носок
     ?runServer
 

Наконец, у нас есть сокет, который прослушивает входящие соединения:

 ok : ()
  носок : Вар
  хорошо1 : ()
  m : Тип -> Тип
  ограничение: ConsoleIO m
  ограничение1 : Сокеты m
--------------------------------------
runServer: STrans m () [sock ::: Sock Listening]
                   (\результат1 => [])
 

Мы реализуем это в отдельной функции. Тип runServer
сообщает нам, каким должен быть тип echoServer (отмечая, что нам нужно
дать m аргумент для Sock явно):

 echoServer : (ConsoleIO m, Sockets m) => (sock : Var) ->
             ST m () [удалить носок (Sock {m} Listening)]
 

Мы можем завершить определение startServer следующим образом:

 startServer : (ConsoleIO m, Sockets m) => ST m () []
стартовый сервер =
  do Right sock <- socket Stream | Левая ошибка => чистая ()
     Правильно ок <- привязать носок Ничего 9442 | Левая ошибка => удалить носок
     Правильно ок <- слушать носок | Левая ошибка => удалить носок
     носок эхосервера
 

В echoServer мы продолжим принимать запросы и отвечать на них
пока что-то не выйдет из строя, после чего мы закроем сокеты и
возвращаться. Начнем с попытки принять входящее соединение:

 echoServer : (ConsoleIO m, Sockets m) => (sock : Var) ->
             ST m () [удалить носок (Sock {m} Listening)]
носок эхо-сервера =
  делать правильно новый <- принять носок | Левая ошибка => закрыть носок; снять носок
     ?что теперь
 

Если принять не удается, нам нужно закрыть Прослушивание сокета и
удалите его перед возвратом, потому что тип echoServer требует
это.

Как всегда, постепенное внедрение echoServer означает, что мы можем проверить
состояние, в котором мы находимся, когда мы развиваемся. Если принять успешно, мы имеем
существующий sock , который все еще прослушивает соединения, и новый
сокет, который открыт для связи:

 новый : Var
  носок : Вар
  m : Тип -> Тип
  ограничение: ConsoleIO m
  ограничение1 : Сокеты m
--------------------------------------
whatNow: STrans m () [sock ::: Sock Listening, новый ::: Sock Open]
                      (\результат1 => [])
 

Для завершения echoServer мы получим сообщение на новый
socket и повторить его обратно. Когда мы закончим, мы закроем новый сокет ,
и вернуться к началу echoServer для обработки следующего
подключение:

 echoServer: (ConsoleIO m, Sockets m) => (sock: Var) ->
             ST m () [удалить носок (Sock {m} Listening)]
носок эхо-сервера =
  делать правильно новый <- принять носок | Левая ошибка => закрыть носок; снять носок
     Правильный msg <- recv новый | Левая ошибка => закрыть носок; снять носок; удалить новый
     Правильно ок <- отправить новый ("Вы сказали " ++ msg)
           | Левая ошибка => удалить новый; закрыть носок; снять носок
     закрыть новый; удалить новый; носок эхосервера
 

Реализация

Sockets

Чтобы реализовать Sockets в IO , мы начнем с указания конкретного типа
для Носок . Мы можем использовать API необработанных сокетов (реализованный в
Network.Socket ) для этого и используйте Socket , хранящийся в State , no
независимо от того, в каком абстрактном состоянии находится сокет:

 реализация Sockets IO, где
  Sock _ = сокет состояния
 

Большинство методов можно реализовать с помощью API сырых сокетов.
напрямую, возвращая Левый или Правый в зависимости от ситуации. Например,
мы можем реализовать socket , bind и listen следующим образом:

 socket ty = do Right sock <- lift $ Socket.socket AF_INET ty 0
                    | Левая ошибка => чистая (левая ())
               lbl <- новый носок
               чистый (правильный фунт)
bind sock addr port = do ok <- lift $ bind !(read sock) addr port
                         если нормально /= 0
                            затем чистый (левый ())
                            иначе чисто (Правильно ())
listen sock = do ok <- lift $ listen !(read sock)
                 если нормально /= 0
                    затем чистый (левый ())
                    иначе чисто (Правильно ())
 

Есть небольшая трудность с принять однако, потому что когда мы
используйте новый , чтобы создать новый ресурс для открытого соединения, он появляется
в начале списка ресурсов, а не в конце. Мы можем увидеть это по
написание неполного определения, использование , возвращение , чтобы увидеть, что
ресурсы должны быть, если мы вернем Right lbl :

 accept sock = do Right (conn, addr) <- lift $ accept !(read sock)
                       | Левая ошибка => чистая (левая ())
                 фунт <- новый конн
                 возвращение (правый фунт) ?fixResources
 

Удобно новый добавить ресурс в начало
список, потому что, как правило, это делает автоматическое построение доказательства с
авто -неявно проще для Идриса. С другой стороны, когда мы используем
вызов , чтобы сделать меньший набор ресурсов, обновление с ставит заново
созданные ресурсы в конце списка, потому что в целом это уменьшает
объем повторного заказа ресурсов.

Если мы посмотрим на тип
fixResources , мы видим, что нам нужно сделать, чтобы закончить accept :

 _bindApp0 : Socket
  соединение : сокет
  адрес : SocketAddress
  носок : Вар
  фунт : вар
--------------------------------------
fixResources: STrans IO () [lbl ::: State Socket, sock ::: State Socket]
                      (\value => [sock ::: State Socket, lbl ::: State Socket])
 

Текущий список ресурсов заказан lbl , sock , и они нам нужны
быть в порядке носок , фунтов . Чтобы помочь в этой ситуации,
Control.ST предоставляет примитив toEnd , который перемещает ресурс в
конец списка. Таким образом, мы можем завершить accept следующим образом:

 accept sock = do Right (conn, addr) <- lift $ accept !(читать sock)
                       | Левая ошибка => чистая (левая ())
                 фунт <- новый конн
                 возврат (справа фунт) (до конца фунт)
 

Для полной реализации Розетки , взгляните на
семплов/ST/Net/Network.idr в дистрибутиве Idris. Вы также можете
найдите там полный эхо-сервер, EchoServer.idr . Есть также
сетевой протокол более высокого уровня, RandServer.idr , с использованием иерархии
конечные автоматы для реализации высокоуровневого сетевого протокола связи
с точки зрения API сокетов нижнего уровня. Это также использует многопоточность, чтобы
обрабатывать входящие запросы асинхронно. Вы можете найти более подробную информацию
о многопоточности и сервере случайных чисел в черновом документе
Конечные автоматы на всем пути вниз
Эдвин Брэди.