zshtcpsys - Online na nuvem

PROGRAMA:

NOME

zshtcpsys - sistema zsh tcp

DESCRIÇÃO

Um módulo zsh / net / tcp é fornecido para fornecer E / S de rede sobre TCP / IP de dentro do shell;
veja sua descrição em módulos zsh(1). Esta página do manual descreve um conjunto de funções com base
no módulo. Se o módulo estiver instalado, as funções geralmente são instaladas no
ao mesmo tempo, caso em que estarão disponíveis para carregamento automático na função padrão
caminho de pesquisa. Em adição ao zsh / net / tcp módulo, o zsh / zselect módulo é usado para
implementar tempos limite em operações de leitura. Para obter dicas de solução de problemas, consulte o
conselho correspondente para o zftp funções descritas em zshzftpsis(1).

Existem funções correspondentes às operações básicas de I / O abrir, fechar, ler e enviar,
nomeado tcp_open etc., bem como uma função tcp_expect para análise de correspondência de padrão de dados
lido como entrada. O sistema torna mais fácil receber e enviar dados para vários
sessões nomeadas de uma vez. Além disso, ele pode ser vinculado ao editor de linha do shell em
de forma que os dados de entrada sejam mostrados automaticamente no terminal. Outras instalações
disponível, incluindo registro, filtragem e prompts de saída configuráveis.

Para usar o sistema onde está disponível, deve ser suficiente para `autoload -U tcp_open'e
corrida tcp_open conforme documentado abaixo para iniciar uma sessão. o tcp_open função irá carregar automaticamente
as demais funções.

TCP USUÁRIO FUNÇÕES

Basico I / O
tcp_open [ -qz ] hospedeiro porta [ Sess ]
tcp_open [ -qz ] [ -s Sess | -l Sess[,...]] ...
tcp_open [ -qz ] [ -a fd | -f fd ] [ Sess ]
Abra uma nova sessão. Na primeira e mais simples forma, abra uma conexão TCP para hospedar
hospedeiro no porto porta; formas numéricas e simbólicas são entendidas para ambos.

If Sess é fornecido, este se torna o nome da sessão que pode ser usado para se referir
para várias conexões TCP diferentes. Se Sess não for fornecido, a função irá
invente um valor de nome numérico (note que isto é não o mesmo que o descritor de arquivo para
à qual a sessão está anexada). Recomenda-se que os nomes das sessões não incluam
personagens 'engraçados', onde personagens engraçados não são bem definidos, mas certamente
não inclui alfanuméricos ou sublinhados e certamente inclui espaços em branco.

No segundo caso, uma ou mais sessões a serem abertas são indicadas por nome. Um único
o nome da sessão é dado após -s e uma lista separada por vírgulas após -l; ambas as opções
pode ser repetido quantas vezes forem necessárias. Uma falha ao abrir qualquer sessão causa
tcp_open para abortar. O host e a porta são lidos do arquivo .ztcp_sessions no
mesmo diretório dos arquivos de inicialização zsh do usuário, ou seja, geralmente a casa
diretório, mas $ ZDOTDIR se isso estiver definido. O arquivo consiste em linhas, cada uma dando um
nome da sessão e o host e porta correspondentes, nessa ordem (observe a sessão
o nome vem primeiro, não por último), separado por um espaço em branco.

A terceira forma permite conexões TCP passivas e falsas. Se a opção -a é usado,
seu argumento é um descritor de arquivo aberto para escuta de conexões. Sem função
front-end é fornecido para abrir tal descritor de arquivo, mas uma chamada para `ztcp -l porta'
irá criar um com o descritor de arquivo armazenado no parâmetro $ REPLY. O
a porta de escuta pode ser fechada com `ztcp -c fd'. Uma chamada para `tcp_open -a fd' vai
bloquear até que uma conexão TCP remota seja feita para porta na máquina local. Neste
ponto, uma sessão é criada da maneira usual e é amplamente indistinguível de
uma conexão ativa criada com um dos primeiros dois formulários.

Se a opção -f é usado, seu argumento é um descritor de arquivo que é usado diretamente
como se fosse uma sessão TCP. Quão bem o restante do sistema de função TCP
lidar com isso depende do que realmente está por trás deste descritor de arquivo. Um regular
é provável que o arquivo esteja inutilizável; um FIFO (tubo) de algum tipo funcionará melhor, mas
note que não é uma boa ideia duas sessões diferentes tentarem ler
o mesmo FIFO de uma vez.

Se a opção -q é fornecido com qualquer uma das três formas, tcp_open não vai imprimir
mensagens informativas, embora em qualquer caso saia com um apropriado
estado.

Se o editor de linha (zle) estiver em uso, o que normalmente é o caso se o shell estiver
interativo, tcp_open instala um manipulador dentro do zle que verifica se há novos dados
ao mesmo tempo que verifica a entrada do teclado. Isso é conveniente porque o shell
não consome tempo de CPU enquanto espera; o teste é executado pelo sistema operacional.
Dando a opção -z a qualquer uma das formas de tcp_open impede o manipulador de
sendo instalado, portanto, os dados devem ser lidos explicitamente. Observe, no entanto, que isso não é
necessário para executar conjuntos completos de comandos de envio e leitura de uma função, como
zle não está ativo neste ponto. De um modo geral, o manipulador está ativo apenas
quando o shell está esperando por uma entrada em um prompt de comando ou no varado construídas em.
A opção não tem efeito se zle não estiver ativo; `[[ -o zle]]'vai testar para isso.

A primeira sessão a ser aberta torna-se a sessão atual e as chamadas subsequentes para
tcp_open não mude isso. A sessão atual é armazenada no parâmetro
$ TCP_SESS; veja abaixo mais detalhes sobre os parâmetros usados ​​pelo sistema.

A função tcp_on_open, se definido, é chamado quando uma sessão é aberta. Veja o
Descrição abaixo.

tcp_close [ -qn ] [ -a | -l Sess[,...] | Sess ...]
Feche as sessões nomeadas, ou a sessão atual se nenhuma for fornecida, ou todas abertas
sessões se -a é dada. As opções -l e -s são tratados para consistência
de tcp_open, embora o último seja redundante.

Se a sessão que está sendo fechada for a atual, $ TCP_SESS não está definido, não deixando
sessão atual, mesmo se houver outras sessões ainda abertas.

Se a sessão foi aberta com tcp_open -f, o descritor de arquivo está fechado por tanto tempo
pois está no intervalo de 0 a 9 acessível diretamente da linha de comando. Se o
opção -n for fornecido, nenhuma tentativa será feita para fechar os descritores de arquivo neste caso.
A -n opção não é usada para genuíno ztcp sessão; os descritores de arquivo são sempre
encerrada com a sessão.

Se a opção -q for fornecido, nenhuma mensagem informativa será impressa.

tcp_read [ -bdq ] [ -t TO ] [ -T TO ]
[ -a | -u fd[,...] | -l Sess[,...] | -s Sess ...]
Execute uma operação de leitura na sessão atual ou em uma lista de sessões, se houver
são dados com -u, -l or -s, ou todas as sessões abertas se a opção -a é dada. Algum
da -u, -l or -s as opções podem ser repetidas ou misturadas. o -u opção
especifica um descritor de arquivo diretamente (apenas aqueles gerenciados por este sistema são
útil), os outros dois especificam sessões conforme descrito para tcp_open acima.

A função verifica se há novos dados disponíveis em todas as sessões listadas. A menos que
-b for fornecida, ela não bloqueará a espera de novos dados. Qualquer linha de dados
de qualquer uma das sessões disponíveis serão lidas, armazenadas no parâmetro $ TCP_LINE,
e exibido na saída padrão, a menos que $ TCP_SILENT contém uma string não vazia.
Quando impresso na saída padrão, a string $ TCP_PROMPT será mostrado no início
da linha; a forma padrão para isso inclui o nome da sessão que está sendo lida.
Veja abaixo mais informações sobre esses parâmetros. Neste modo, tcp_read pode ser
chamado repetidamente até retornar o status 2, que indica todas as entradas pendentes de
todas as sessões especificadas foram tratadas.

Com a opção -b, equivalente a um tempo limite infinito, a função irá bloquear
até que uma linha esteja disponível para leitura em uma das sessões especificadas. Contudo,
apenas uma única linha é retornada.

A opção -d indica que todas as entradas pendentes devem ser drenadas. Nesse caso
tcp_read pode processar várias linhas da maneira dada acima; apenas o último é
armazenado em $ TCP_LINE, mas o conjunto completo é armazenado na matriz $ tcp_lines. Este
é liberado no início de cada chamada para tcp_read.

As opções -t e -T especifique um tempo limite em segundos, que pode ser um ponto flutuante
número para maior precisão. Com -t o tempo limite é aplicado antes de cada linha
leitura. Com -T, o tempo limite se aplica à operação geral, possivelmente incluindo
múltiplas operações de leitura se a opção -d é presente; sem esta opção, existe
nenhuma distinção entre -t e -T.

A função não imprime mensagens informativas, mas se a opção -q é dada,
nenhuma mensagem de erro é impressa para uma sessão inexistente.

Um status de retorno de 2 indica um tempo limite ou nenhum dado para ler. Qualquer outro diferente de zero
o status de retorno indica alguma condição de erro.

See tcp_log para saber como controlar para onde os dados são enviados tcp_read.

tcp_send [ -cnq ] [ -s Sess | -l Sess[,...]] dados, ...
tcp_send [ -cnq ] -a dados, ...
Envie as strings de dados fornecidas para todas as sessões especificadas, por sua vez. o
operação subjacente difere pouco de um `impressão -r'para o arquivo da sessão
descritor, embora tente evitar que a casca morra devido a um SIGPIPE
causado por uma tentativa de escrever em uma sessão extinta.

A opção -c causas tcp_send se comportar como gato. Ele lê as linhas do padrão
entrada até o final da entrada e os envia por sua vez para a (s) sessão (ões) especificada (s) exatamente
como se fossem dados como dados, argumentos para o indivíduo tcp_send comandos.

A opção -n impede tcp_send de colocar uma nova linha no final dos dados
cordas.

Todas as opções restantes se comportam como para tcp_read.

Os argumentos de dados não são processados ​​posteriormente, uma vez que foram passados ​​para
tcp_send; eles são simplesmente passados ​​para impressão -r.

Se o parâmetro $ TCP_OUTPUT é uma string não vazia e o registro é habilitado então o
os dados enviados para cada sessão serão ecoados no (s) arquivo (s) de log com $ TCP_OUTPUT in
frente quando apropriado, muito na forma de $ TCP_PROMPT.

Número da Assistência Domiciliária
tcp_alias [ -q ] aliás=Sess ...
tcp_alias [ -q ] [ aliás ...]
tcp_alias -d [ -q ] aliás ...
Esta função não é particularmente bem testada.

O primeiro formulário cria um alias para um nome de sessão; aliás pode então ser usado para se referir
para a sessão existente Sess. Podem ser listados tantos apelidos quantos forem necessários.

A segunda forma lista todos os apelidos especificados ou todos os apelidos, se nenhum.

A terceira forma exclui todos os apelidos listados. As sessões subjacentes não são
afetado.

A opção -q suprime um subconjunto de mensagens de erro escolhido de maneira inconsistente.

tcp_log [ -asc ] [ -n | -N ] [ arquivo de log ]
Com uma discussão arquivo de log, todas as contribuições futuras de tcp_read será conectado ao
arquivo nomeado. A não ser que -a (anexar) for fornecido, este arquivo será primeiro truncado ou
criado vazio. Sem argumentos, mostra o status atual do registro.

Com a opção -s, o log por sessão está habilitado. Entrada de tcp_read é saída
para o arquivo arquivo de log.Sess. Como a sessão é automaticamente discriminada pelo
nome do arquivo, o conteúdo é bruto (não $ TCP_PROMPT) A opção -a aplica-se como acima.
O registro por sessão e o registro de todos os dados em um arquivo não são mutuamente exclusivos.

A opção -c fecha todos os registros, tanto os registros completos quanto os por sessão.

As opções -n e -N respectivamente, desligue ou restaure a saída de dados lidos por
tcp_read para saída padrão; portanto `tcp_log -cn'desliga toda a saída por tcp_read.

A função é puramente uma interface conveniente para definir os parâmetros $ TCP_LOG,
$ TCP_LOG_SESS, $ TCP_SILENT, que são descritos abaixo.

tcp_rename velho novo
Renomear sessão velho para a sessão novo. O nome antigo se torna inválido.

tcp_sess [ Sess [ comando [ arg ...]]]
Sem argumentos, liste todas as sessões abertas e descritores de arquivo associados. o
a sessão atual é marcada com uma estrela. Para uso em funções, acesso direto ao
parâmetros $ tcp_by_name, $ tcp_by_fd e $ TCP_SESS é provavelmente mais conveniente; Vejo
abaixo.

Com uma conta na Sess argumento, defina a sessão atual para Sess. Isso é equivalente a
mudança $ TCP_SESS diretamente.

Com argumentos adicionais, defina temporariamente a sessão atual durante a execução
`comando arg ... '. comando é reavaliado para expandir aliases etc., mas o
remanescente args são passados ​​como parecem para tcp_sess. A sessão original
é restaurado quando tcp_sess saídas.

Avançado I / O
tcp_command opção de envio ... enviar-argumento ...
Este é um front-end conveniente para tcp_send. Todos os argumentos são passados ​​para tcp_send,
em seguida, a função pausa à espera de dados. Enquanto os dados chegam, pelo menos a cada
$ TCP_TIMEOUT (padrão 0.3) segundos, os dados são tratados e impressos de acordo com
as configurações atuais. O status 0 é sempre retornado.

Geralmente, isso só é útil para uso interativo, para evitar que a tela se torne
fragmentado pela saída retornada da conexão. Dentro de um programa ou função
geralmente é melhor lidar com a leitura de dados por um método mais explícito.

tcp_expect [ -q ] [ -p var | -P var ] [ -t TO | -T TO ]
[ -a | -s Sess | -l Sess[,...]] de cinto de segurança ...
Aguarde a entrada que corresponda a qualquer um dos dados de cinto de seguranças de qualquer um dos
sessões. A entrada é ignorada até que uma linha de entrada corresponda a um dos padrões fornecidos;
neste ponto, o status zero é retornado, a linha correspondente é armazenada em $ TCP_LINE,
e o conjunto completo de linhas lidas durante a chamada para tcp_expect é armazenado na matriz
$ tcp_expect_lines.

As sessões são especificadas da mesma forma que tcp_read: o padrão é usar o
sessão atual, caso contrário, as sessões especificadas por -a, -sou -l são usados.

Cada de cinto de segurança é um padrão zsh extended-globbing padrão; note que precisa ser
citado para evitar que seja expandido imediatamente pela geração do nome do arquivo. Isso deve
coincidir com a linha inteira, então para coincidir com uma substring deve haver um `*'no início e
fim. A linha correspondida inclui o $ TCP_PROMPT adicionado por tcp_read. É
possível incluir os sinalizadores de globbing `#b'ou `#m'nos padrões para fazer
referências anteriores disponíveis nos parâmetros $ MATCH, $ match, etc., conforme descrito em
a documentação zsh básica sobre correspondência de padrões.

Diferentemente dos tcp_read, o comportamento padrão de tcp_expect é bloquear indefinidamente até
a entrada necessária foi encontrada. Isso pode ser modificado especificando um tempo limite com -t
or -T; estes funcionam como em tcp_read, especificando um tempo limite por leitura ou geral,
respectivamente, em segundos, como um número inteiro ou de ponto flutuante. Como tcp_read,
a função retorna o status 2 se ocorrer um tempo limite.

A função retorna assim que qualquer um dos padrões fornecidos corresponder. Se o chamador
precisa saber quais padrões correspondem, a opção -p var pode ser usado; sobre
Retorna, $ var é definido como o número do padrão usando a indexação zsh comum, ou seja,
o primeiro é 1 e assim por diante. Observe a ausência de um `$' em frente var. Evitar
confrontos, o parâmetro não pode começar com `_Espero'. O índice -1 é usado se houver
é um tempo limite e 0 se não houver correspondência.

A opção -P var funciona de forma semelhante a -p, mas em vez de índices numéricos, o
argumentos regulares devem começar com um prefixo seguido por dois pontos: esse prefixo é então
usado como uma tag para a qual var é definido quando o argumento corresponde. A etiqueta tempo limite is
usado se houver um tempo limite e a string vazia se não houver correspondência. Observe que é
aceitável para diferentes argumentos para começar com o mesmo prefixo se as correspondências
não precisa ser distinguido.

A opção -q é passado diretamente para tcp_read.

Como toda entrada é feita via tcp_read, todas as regras usuais sobre saída de linhas lidas
Aplique. Uma exceção é que o parâmetro $ tcp_lines irá apenas refletir a linha
realmente correspondido por tcp_expect; usar $ tcp_expect_lines para o conjunto completo de linhas
lido durante a chamada de função.

tcp_proxy
Esta é uma função simples para aceitar uma conexão TCP e executar um comando
com I / O redirecionado para a conexão. Extremo cuidado deve ser tomado, pois há
sem qualquer tipo de segurança e isso pode deixar seu computador aberto para o mundo.
Idealmente, ele só deve ser usado atrás de um firewall.

O primeiro argumento é uma porta TCP na qual a função ouvirá.

Os argumentos restantes fornecem um comando e seus argumentos para executar com padrão
entrada, saída padrão e erro padrão redirecionados para o descritor de arquivo em
qual a sessão TCP foi aceita. Se nenhum comando for dado, um novo zsh é
iniciado. Isso dá a todos em sua rede acesso direto à sua conta, o que
em muitos casos, será uma coisa ruim.

O comando é executado em segundo plano, então tcp_proxy pode então aceitar novas conexões.
Ele continua a aceitar novas conexões até ser interrompido.

tcp_spam [ -ertv ] [ -a | -s Sess | -l Sess[,...]] cmd [ arg ...]
Executar `cmd [ arg ...] 'para cada sessão sucessivamente. Observe que isto executa o comando
e argumentos; ele não envia a linha de comando como dados, a menos que o -t (transmite)
opção é fornecida.

As sessões podem ser selecionadas explicitamente com o padrão -a, -s or -l opções, ou
pode ser escolhido implicitamente. Se nenhuma das três opções for fornecida, as regras são:
primeiro, se a matriz $ tcp_spam_list é definido, isso é considerado como a lista de sessões,
caso contrário, todas as sessões serão realizadas. Em segundo lugar, todas as sessões fornecidas na matriz
$ tcp_no_spam_list são removidos da lista de sessões.

Normalmente, todas as sessões adicionadas pelo `-a'ou quando todas as sessões forem escolhidas
implicitamente são enviados por spam em ordem alfabética; sessões dadas pelo $ tcp_spam_list
array ou na linha de comando são spammados na ordem fornecida. o -r bandeira inverte
a ordem no entanto foi chegada a ela.

A -v flag especifica que um $ TCP_PROMPT será produzido antes de cada sessão. Esse
é produzido após qualquer modificação para TCP_SESS pelo definido pelo usuário tcp_on_spam
função descrita abaixo. (Obviamente, essa função é capaz de gerar seus próprios
saída.)

Se a opção -e está presente, a linha fornecida como `cmd [ arg ...] 'é executado usando
avaliação, caso contrário, ele é executado sem qualquer processamento adicional.

tcp_talk
Esta é uma tentativa bastante simplória de forçar a entrada para o editor de linha a ir
direto para o padrão TCP_SESS.

Uma string de escape, $ TCP_TALK_ESCAPE, padrão `:', é usado para permitir o acesso ao normal
operação shell. Se estiver sozinho no início da linha, ou seguido apenas por
espaço em branco, o editor de linha retorna à operação normal. Caso contrário, a string e
qualquer espaço em branco a seguir é ignorado e o restante da linha executado como
entrada do shell sem qualquer alteração do modo de operação do editor de linha.

A implementação atual é um tanto deficiente em termos de uso do comando
história. Por este motivo, muitos usuários preferem usar alguma forma de alternativa
abordagem para enviar dados facilmente para a sessão atual. Uma abordagem simples é
alias algum caractere especial (como `%') para `tcp_command --'.

tcp_wait
O único argumento é um número inteiro ou de ponto flutuante que dá os segundos para
atraso. O shell não fará nada durante esse período, exceto esperar por entrada em todos os TCP
sessões chamando tcp_read -a. Isso é semelhante ao comportamento interativo em
o prompt de comando quando os manipuladores zle são instalados.

'One-shot' lima transferência
ponto_tcp porta
tcp_shoot hospedeiro porta
Este par de funções fornece uma maneira simples de transferir um arquivo entre dois hosts
dentro da concha. Observe, no entanto, que a transferência de dados em massa é feita atualmente usando
gato. ponto_tcp lê todos os dados que chegam a porta e o envia para a saída padrão;
tcp_shoot se conecta a porta on hospedeiro e envia sua entrada padrão. Qualquer não utilizado porta
pode ser usado; o mecanismo padrão para escolher uma porta é pensar em uma porta aleatória
número de quatro dígitos acima de 1024 até que um funcione.

Para transferir um arquivo do host galinhola hospedar Springes, Em Springes:

ponto_tcp 8091 > output_file

e na galinhola:

tcp_shoot Springes 8091 <arquivo_de_entrada

Como essas duas funções não requerem tcp_open para configurar uma conexão TCP primeiro,
eles podem precisar ser carregados automaticamente separadamente.

TCP USUÁRIO DEFINIDO FUNÇÕES

Certas funções, se definidas pelo usuário, serão chamadas pelo sistema de funções em
certos contextos. Esta facilidade depende do módulo zsh / parâmetro, que geralmente é
disponível em shells interativos, pois o sistema de completação depende disso. Nenhum dos
funções precisam ser definidas; eles simplesmente fornecem ganchos convenientes quando necessário.

Normalmente, eles são chamados após a ação solicitada ter sido executada, para que os vários
os parâmetros refletirão o novo estado.

tcp_on_alias aliás fd
Quando um alias é definido, esta função será chamada com dois argumentos: o nome
do alias e o descritor de arquivo da sessão correspondente.

tcp_on_awol Sess fd
Se a função tcp_fd_handler está lidando com a entrada do editor de linha e detecta
que o descritor de arquivo não é mais reutilizável, por padrão ele o remove do
lista de descritores de arquivo tratados por este método e imprime uma mensagem. Se o
função tcp_on_awol é definido, ele é chamado imediatamente antes deste ponto. Pode
status de retorno 100, que indica que o manuseio normal ainda deve ser
realizada; qualquer outro status de retorno indica que nenhuma ação adicional deve ser tomada
e os votos de tcp_fd_handler deve retornar imediatamente com o status fornecido. Tipicamente
a ação de tcp_on_awol será para encerrar a sessão.

A variável TCP_INVALIDATE_ZLE será uma string não vazia se for necessário
invalidar a exibição do editor de linha usando `zelo -I'antes de imprimir a saída do
função.

(`AWOL 'é o jargão militar para` ausente sem licença' ou alguma variação. Não tem
significado técnico pré-existente conhecido do autor.)

tcp_on_close Sess fd
Isso é chamado com o nome de uma sessão sendo fechada e o descritor de arquivo
que correspondia a essa sessão. Ambos serão inválidos no momento em que a função
é chamado.

tcp_on_open Sess fd
É chamado após uma nova sessão ter sido definida com o nome da sessão e arquivo
descritor como argumentos. Se retornar um status diferente de zero, a abertura da sessão é
presume-se que falhe e a sessão seja encerrada novamente; Contudo, tcp_open continuará
tenta abrir qualquer sessão restante fornecida na linha de comando.

tcp_on_rename velhinha fd notícias
É chamado depois de uma sessão ter sido renomeada com os três argumentos antigos
nome da sessão, descritor de arquivo, novo nome da sessão.

tcp_on_spam Sess comando ...
Isso é chamado uma vez para cada sessão com spam, apenas antes um comando é executado para
uma sessão por tcp_spam. Os argumentos são o nome da sessão seguido pelo comando
lista a ser executada. Se tcp_spam foi chamado com a opção -t, o primeiro comando
será tcp_send.

Esta função é chamada após $ TCP_SESS está definido para refletir a sessão a ser
spam, mas antes que qualquer uso dele seja feito. Portanto, é possível alterar o valor
of $ TCP_SESS dentro desta função. Por exemplo, os argumentos da sessão para tcp_spam
pode incluir informações extras a serem retiradas e processadas em tcp_on_spam.

Se a função define o parâmetro $ REPLY para `feito', a linha de comando não é
executado; além disso, nenhum prompt é impresso para o -v opção para tcp_spam.

tcp_on_unalias aliás fd
É chamado com o nome de um alias e o arquivo da sessão correspondente
descritor após a exclusão de um alias.

TCP UTILIDADE FUNÇÕES

As funções a seguir são usadas pelo sistema de funções TCP, mas raramente ou nunca precisarão
para ser chamado diretamente.

tcp_fd_handler
Esta é a função instalada por tcp_open para lidar com a entrada de dentro da linha
editor, se for necessário. Está no formato documentado para o `zelo
-F' em zshzle(1)

Enquanto ativa, a função define o parâmetro TCP_HANDLER_ACTIVE para 1. Isso permite
código de shell chamado internamente (por exemplo, definindo tcp_on_read) para saber se é
sendo chamado quando o shell está ocioso no prompt do editor.

tcp_output [ -q ] -P pronto -F fd -S Sess
Esta função é usada para registrar e manipular a saída para a saída padrão, de
dentro tcp_read e se $ TCP_OUTPUT está definido) tcp_send.

A pronto para usar é especificado por -P; o padrão é a string vazia. Pode
conter:
%c Expande-se para 1 se a sessão for a sessão atual, caso contrário, 0. Usado com
expressões ternárias como `% (c .-. +)'para saída `+'para a sessão atual
e `-' de outra forma.

%f Substituído pelo descritor de arquivo da sessão.

%s Substituído pelo nome da sessão.

%% Substituído por um único `%'.

A opção -q suprime a saída para a saída padrão, mas não para quaisquer arquivos de log que
estão configurados.

A -S e -F opções são usadas para passar o nome da sessão e o descritor de arquivo para
possível substituição no prompt.

TCP USUÁRIO PARÂMETROS

Os parâmetros seguem a convenção usual de que maiúsculas são usadas para escalares e inteiros,
enquanto a minúscula é usada para array normal e associativo. É sempre seguro para o código do usuário
para ler esses parâmetros. Alguns parâmetros também podem ser definidos; estes são anotados explicitamente.
Outros estão incluídos neste grupo, pois são definidos pelo sistema de funções para o usuário
benefício, ou seja, defini-los normalmente não é útil, mas é benigno.

Freqüentemente, também é útil tornar os parâmetros configuráveis ​​locais para uma função. Por exemplo,
`local TCP_SILENT = 1'especifica que os dados lidos durante a chamada de função não serão impressos
para a saída padrão, independentemente da configuração fora da função. Da mesma forma, `local
TCP_SESS =Sess'define uma sessão para a duração de uma função, e `local TCP_PROMPT ='
especifica que nenhum prompt é usado para entrada durante a função.

tcp_expect_lines
Variedade. O conjunto de linhas lidas durante a última chamada para tcp_expect, Incluindo o
último ($ TCP_LINE).

filtro_tcp
Variedade. Pode ser definido diretamente. Um conjunto de padrões de globbing estendidos que, se combinados
in tcp_output, fará com que a linha não seja impressa na saída padrão. o
padrões devem ser definidos conforme descrito para os argumentos para tcp_expect. Saída de
linha para arquivos de log não é afetada.

TCP_HANDLER_ACTIVE
Escalar. Definido como 1 em tcp_fd_handler para indicar funções chamadas recursivamente
que foram chamados durante uma sessão do editor. Caso contrário, não definido.

TCP_LINE
A última linha lida por tcp_reade, portanto, também tcp_expect.

TCP_LINE_FD
O descritor de arquivo do qual $ TCP_LINE foi lido. $ {tcp_by_fd [$ TCP_LINE_FD]} precisarão
forneça o nome da sessão correspondente.

tcp_lines
Variedade. O conjunto de linhas lidas durante a última chamada para tcp_read, incluindo o último
($ TCP_LINE).

TCP_LOG
Pode ser definido diretamente, embora também seja controlado por tcp_log. O nome de um arquivo
para o qual a saída de todas as sessões será enviada. A saída é seguida pelo
habitual $ TCP_PROMPT. Se não for um nome de caminho absoluto, ele seguirá o usuário
diretório atual.

TCP_LOG_SESS
Pode ser definido diretamente, embora também seja controlado por tcp_log. O prefixo para um
conjunto de arquivos para os quais a saída de cada sessão separadamente será enviada; o cheio
nome do arquivo é $ {TCP_LOG_SESS}.Sess. A saída para cada arquivo é bruta; nenhum prompt é adicionado.
Se não for um nome de caminho absoluto, ele seguirá o diretório atual do usuário.

tcp_no_spam_list
Variedade. Pode ser definido diretamente. Ver tcp_spam para saber como isso é usado.

TCP_OUTPUT
Pode ser definido diretamente. Se for uma string não vazia, quaisquer dados enviados para uma sessão por tcp_send
será registrado. Este parâmetro fornece o prompt para ser usado em um arquivo especificado por
$ TCP_LOG mas não em um arquivo gerado a partir de $ TCP_LOG_SESS. A string do prompt tem o
mesmo formato que TCP_PROMPT e as mesmas regras para seu uso se aplicam.

TCP_PROMPT
Pode ser definido diretamente. Usado como prefixo para dados lidos por tcp_read que é impresso
para a saída padrão ou para o arquivo de log fornecido por $ TCP_LOG, caso existam. Qualquer `%s', `%f' ou
`%%'ocorrendo na string será substituído pelo nome da sessão, o
descritor de arquivo subjacente da sessão, ou um único `%', respectivamente. o
expressão `%c'se expande para 1 se a sessão que está sendo lida for a sessão atual, caso contrário
0; isso é mais útil em expressões ternárias como `% (c .-. +)'que produz `+'
se a sessão for a atual, senão `-'.

Se o prompt começar com %P, isso é retirado e o resultado completo do
o estágio anterior é passado pelo prompt padrão %formatação de estilo antes de ser
saída.

TCP_READ_DEBUG
Pode ser definido diretamente. Se este tiver comprimento diferente de zero, tcp_read vai dar algum limitado
diagnósticos sobre os dados que estão sendo lidos.

TCP_SECONDS_START
Este valor é criado e inicializado em zero por tcp_open.

As funções tcp_read e tcp_expect use a concha SEGUNDOS parâmetro para o seu
propósitos próprios de cronometragem. Se esse parâmetro não for do tipo ponto flutuante na entrada para
uma das funções, ele irá criar um parâmetro local SEGUNDOS que está flutuando
apontar e definir o parâmetro TCP_SECONDS_START ao valor anterior de $ SECONDS.
Se o parâmetro já é ponto flutuante, ele é usado sem uma cópia local sendo
criado e TCP_SECONDS_START não está definido. Como o valor global é zero, o shell
o tempo decorrido é garantido como a soma de $ SECONDS e $ TCP_SECONDS_START.

Isso pode ser evitado definindo SEGUNDOS globalmente para um valor de ponto flutuante usando
`formatado -F SEGUNDOS'; então as funções TCP nunca farão uma cópia local e nunca
conjunto TCP_SECONDS_START para um valor diferente de zero.

TCP_SESS
Pode ser definido diretamente. A sessão atual; deve referir-se a uma das sessões
estabelecido por tcp_open.

TCP_SILENT
Pode ser definido diretamente, embora também seja controlado por tcp_log. Se diferente de zero
comprimento, dados lidos por tcp_read não será gravado na saída padrão, embora possa
ainda será gravado em um arquivo de log.

tcp_spam_list
Variedade. Pode ser definido diretamente. Veja a descrição da função tcp_spam por quanto
isso é usado.

TCP_TALK_ESCAPE
Pode ser definido diretamente. Veja a descrição da função tcp_talk por como isso é
usava.

TCP_TIMEOUT
Pode ser definido diretamente. Atualmente, isso é usado apenas pela função tcp_command, Ver
acima.

TCP USUÁRIO DEFINIDO PARÂMETROS

Os parâmetros a seguir não são definidos pelo sistema de funções, mas têm um efeito especial se
definido pelo usuário.

tcp_on_read
Deve ser uma matriz associativa; se não for, o comportamento é indefinido.
Cada chave é o nome de uma função shell ou outro comando, e o correspondente
valor é um padrão de shell (usando EXTENDED_GLOB) Cada linha lida de uma sessão TCP
direta ou indiretamente usando tcp_read (que inclui linhas lidas por tcp_expect) é
em comparação com o padrão. Se a linha corresponder, o comando dado na chave é
chamado com dois argumentos: o nome da sessão da qual a linha foi lida,
e a própria linha.

Se qualquer função chamada para lidar com uma linha retornar um status diferente de zero, a linha não é
saída. Assim, um tcp_on_read manipulador contendo apenas a instrução `retorno 1' posso
ser usado para suprimir a saída de linhas específicas (consulte, no entanto, filtro_tcp acima).
No entanto, a linha ainda está armazenada em TCP_LINE e tcp_lines; isso ocorre afinal
tcp_on_read processamento.

TCP UTILIDADE PARÂMETROS

Esses parâmetros são controlados pelo sistema de funções; eles podem ser lidos diretamente, mas
geralmente não deve ser definido pelo código do usuário.

tcp_aliases
Matriz associativa. As chaves são os nomes das sessões estabelecidas com tcp_open;
cada valor é uma lista separada por espaço de aliases que se referem a essa sessão.

tcp_by_fd
Matriz associativa. As chaves são descritores de arquivo de sessão; cada valor é o nome
dessa sessão.

tcp_by_name
Matriz associativa. As chaves são os nomes das sessões; cada valor é o arquivo
descritor associado a essa sessão.

TCP EXEMPLOS

Aqui está um exemplo trivial usando uma calculadora remota.

Para criar um servidor de calculadora na porta 7337 (consulte o dc página de manual para saber como
enfurecer o comando subjacente é):

tcp_proxy 7337 dc

Para se conectar a este a partir do mesmo host com uma sessão também chamada `dc':

tcp_open localhost 7337 dc

Para enviar um comando para a sessão remota e esperar um pouco pela saída (assumindo dc is
a sessão atual):

tcp_command 2 4 + p

Para fechar a sessão:

tcp_close

A tcp_proxy precisa ser morto para ser interrompido. Observe que isso geralmente não mata nenhum
conexões que já foram aceitas, e também que a porta não é imediatamente
disponível para reutilização.

O seguinte pedaço de código coloca uma lista de sessões em um cabeçalho xterm, com o atual
sessão seguida por uma estrela.

impressão -n "\ 033] 2; TCP:" $ {(k) tcp_by_name: / $ TCP_SESS / $ TCP_SESS \ *} "\uma"

TCP INSETOS

A função tcp_read usa o shell do normal ler construídas em. À medida que lê uma linha completa
de uma vez, os dados que chegam sem uma nova linha final podem fazer com que a função bloqueie
indefinidamente.

Embora o conjunto de funções funcione bem para uso interativo e para dados que chegam em pequenos
valores, o desempenho quando grandes quantidades de dados estão sendo trocados provavelmente será
extremamente pobre.

Use zshtcpsys online usando serviços onworks.net