Translation

(itstool) path: sect4/para
English
Indeed, when we enter a port number, it is because we want the other computer to know what service we are asking for. And, when we are the server, we read the port number so we know what service the other computer is expecting from us. Either way, sockets only has to forward the port number as data. It does not interpret it in any way.
358/3370
Context English Portuguese (Brazil) State
_ external ref='sockets/sainlsb' md5='__failed__' external ref='sockets/sainlsb' md5='__failed__'
0 1 2 3
+--------+--------+--------+--------+
0 | 0 | 2 | 13 | 0 |
+--------+--------+--------+--------+
4 | 18 | 244 | 43 | 192 |
+-----------------------------------+
8 | 0 |
+-----------------------------------+
12 | 0 |
+-----------------------------------+
0 1 2 3
+--------+--------+--------+--------+
0 | 0 | 2 | 13 | 0 |
+--------+--------+--------+--------+
4 | 18 | 244 | 43 | 192 |
+-----------------------------------+
8 | 0 |
+-----------------------------------+
12 | 0 |
+-----------------------------------+
<imageobject> <imagedata fileref="sockets/sainlsb"/> </imageobject> <textobject> <_:literallayout-1/> </textobject> <textobject> <phrase>sockaddr_in on an Intel system</phrase> </textobject> <imageobject><imagedata fileref="sockets/sainlsb"/></imageobject><textobject> &lt;_: literallayout-1 /&gt; </textobject><textobject><phrase> sockaddr_in em um sistema Intel </phrase></textobject>
On a different system, it might look like this: Em um sistema diferente, pode ser assim:
_ external ref='sockets/sainmsb' md5='__failed__' external ref='sockets/sainmsb' md5='__failed__'
0 1 2 3
+--------+--------+--------+--------+
0 | 0 | 2 | 0 | 13 |
+--------+--------+--------+--------+
4 | 192 | 43 | 244 | 18 |
+-----------------------------------+
8 | 0 |
+-----------------------------------+
12 | 0 |
+-----------------------------------+
0 1 2 3
+--------+--------+--------+--------+
0 | 0 | 2 | 0 | 13 |
+--------+--------+--------+--------+
4 | 192 | 43 | 244 | 18 |
+-----------------------------------+
8 | 0 |
+-----------------------------------+
12 | 0 |
+-----------------------------------+
<imageobject> <imagedata fileref="sockets/sainmsb"/> </imageobject> <textobject> <_:literallayout-1/> </textobject> <textobject> <phrase>sockaddr_in on an MSB system</phrase> </textobject> <imageobject><imagedata fileref="sockets/sainmsb"/></imageobject><textobject> &lt;_: literallayout-1 /&gt; </textobject><textobject><phrase> sockaddr_in em um sistema MSB </phrase></textobject>
And on a PDP it might look different yet. But the above two are the most common ways in use today. E em um PDP pode parecer diferente ainda. Mas os dois acima são as formas mais comuns em uso hoje.
Ordinarily, wanting to write portable code, programmers pretend that these differences do not exist. And they get away with it (except when they code in assembly language). Alas, you cannot get away with it that easily when coding for sockets. Normalmente, querendo escrever códigos portáveis, os programadores fingem que essas diferenças não existem. E eles se safam (exceto quando eles codificam na linguagem assembly). Infelizmente, você não pode se safar tão facilmente quando codifica para sockets.
Why? Por quê?
Because when communicating with another computer, you usually do not know whether it stores data <emphasis>most significant byte</emphasis> (<acronym>MSB</acronym>) or <emphasis>least significant byte</emphasis> (<acronym>LSB</acronym>) first. Porque quando se comunica com outro computador, você geralmente não sabe se ele armazena dados <emphasis> byte mais significativo </emphasis> ( <acronym>MSB</acronym> ) ou <emphasis> byte menos significativo </emphasis> ( <acronym>LSB</acronym> ) primeiro.
You might be wondering, <emphasis><quote>So, will sockets not handle it for me?</quote></emphasis> Você pode estar se perguntando, <emphasis><quote> Então, soquetes não vão lidar com isso para mim? </quote></emphasis>
It will not. Não vai.
While that answer may surprise you at first, remember that the general sockets interface only understands the <varname>sa_len</varname> and <varname>sa_family</varname> fields of the <varname>sockaddr</varname> structure. You do not have to worry about the byte order there (of course, on FreeBSD <varname>sa_family</varname> is only 1 byte anyway, but many other <trademark class="registered">UNIX</trademark> systems do not have <varname>sa_len</varname> and use 2 bytes for <varname>sa_family</varname>, and expect the data in whatever order is native to the computer). Embora essa resposta possa surpreendê-lo a princípio, lembre-se de que a interface geral de soquetes apenas compreende <varname> sa_len </varname> e <varname> sa_family </varname> campos do <varname> sockaddr </varname> estrutura. Você não precisa se preocupar com a ordem de bytes lá (é claro, no FreeBSD <varname> sa_family </varname> é apenas 1 byte, mas muitos outros <trademark class="registered"> UNIX </trademark> sistemas não têm <varname> sa_len </varname> e use 2 bytes para <varname> sa_family </varname> e espere que os dados em qualquer ordem sejam nativos para o computador).
But the rest of the data is just <varname>sa_data[14]</varname> as far as sockets goes. Depending on the <emphasis>address family</emphasis>, sockets just forwards that data to its destination. Mas o resto dos dados é apenas <varname> sa_data [14] </varname> tanto quanto os soquetes vão. Dependendo do <emphasis> família de endereço </emphasis> , soquetes apenas encaminha esses dados para o seu destino
Indeed, when we enter a port number, it is because we want the other computer to know what service we are asking for. And, when we are the server, we read the port number so we know what service the other computer is expecting from us. Either way, sockets only has to forward the port number as data. It does not interpret it in any way. De fato, quando inserimos um número de porta, é porque queremos que o outro computador saiba qual serviço estamos pedindo. E, quando somos o servidor, lemos o número da porta para sabermos qual serviço o outro computador está esperando De qualquer forma, os soquetes só precisam encaminhar o número da porta como dados. Ele não o interpreta de forma alguma.
Similarly, we enter the <acronym>IP</acronym> address to tell everyone on the way where to send our data to. Sockets, again, only forwards it as data. Da mesma forma, nós entramos no endereço <acronym>IP</acronym> para informar a todos no caminho para onde enviar nossos dados. Sockets, novamente, apenas o encaminha como dados.
That is why, we (the <emphasis>programmers</emphasis>, not the <emphasis>sockets</emphasis>) have to distinguish between the byte order used by our computer and a conventional byte order to send the data in to the other computer. É por isso que nós (o <emphasis> programadores </emphasis> , não o <emphasis> tomadas </emphasis> ) tem que distinguir entre a ordem de byte usada pelo nosso computador e uma ordem de byte convencional para enviar os dados para o outro computador.
We will call the byte order our computer uses the <emphasis>host byte order</emphasis>, or just the <emphasis>host order</emphasis>. Vamos chamar a ordem de bytes que o nosso computador usa <emphasis> ordem de byte de host </emphasis> ou apenas o <emphasis> ordem de host </emphasis>
There is a convention of sending the multi-byte data over <acronym>IP</acronym> <emphasis><acronym>MSB</acronym> first</emphasis>. This, we will refer to as the <emphasis>network byte order</emphasis>, or simply the <emphasis>network order</emphasis>. Existe uma convenção de envio de dados multi-byte sobre <acronym>IP</acronym> <emphasis> <acronym>MSB</acronym> primeiro </emphasis> . Isso, nos referiremos como <emphasis> ordem de bytes de rede </emphasis> , ou simplesmente o <emphasis> ordem de rede </emphasis>
Now, if we compiled the above code for an Intel based computer, our <emphasis>host byte order</emphasis> would produce: Agora, se compilássemos o código acima para um computador baseado em Intel, <emphasis> ordem de byte de host </emphasis> produziria:
<imageobject> <imagedata fileref="sockets/sainlsb"/> </imageobject> <textobject> <_:literallayout-1/> </textobject> <textobject> <phrase>Host byte order on an Intel system</phrase> </textobject> <imageobject><imagedata fileref="sockets/sainlsb"/></imageobject><textobject> &lt;_: literallayout-1 /&gt; </textobject><textobject><phrase> Ordem de bytes de host em um sistema Intel </phrase></textobject>
But the <emphasis>network byte order</emphasis> requires that we store the data <acronym>MSB</acronym> first: Mas o <emphasis> ordem de bytes de rede </emphasis> exige que armazenemos primeiro os dados do <acronym>MSB</acronym> :
<imageobject> <imagedata fileref="sockets/sainmsb"/> </imageobject> <textobject> <_:literallayout-1/> </textobject> <textobject> <phrase>Network byte order</phrase> </textobject> <imageobject><imagedata fileref="sockets/sainmsb"/></imageobject><textobject> &lt;_: literallayout-1 /&gt; </textobject><textobject><phrase> Ordem de bytes de rede </phrase></textobject>
Unfortunately, our <emphasis>host order</emphasis> is the exact opposite of the <emphasis>network order</emphasis>. Infelizmente, nossa <emphasis> ordem de host </emphasis> é exatamente o oposto do <emphasis> ordem de rede </emphasis>
We have several ways of dealing with it. One would be to <emphasis>reverse</emphasis> the values in our code: Temos várias maneiras de lidar com isso. Uma seria <emphasis> marcha ré </emphasis> os valores em nosso código:
sa.sin_family = AF_INET;
sa.sin_port = 13 &lt;&lt; 8;
sa.sin_addr.s_addr = (((((18 &lt;&lt; 8) | 244) &lt;&lt; 8) | 43) &lt;&lt; 8) | 192;
sa.sin_family = AF_INET;
sa.sin_port = 13 &lt;&lt; 8;
sa.sin_addr.s_addr = (((((18 &lt;&lt; 8) | 244) &lt;&lt; 8) | 43) &lt;&lt; 8) | 192;
This will <emphasis>trick</emphasis> our compiler into storing the data in the <emphasis>network byte order</emphasis>. In some cases, this is exactly the way to do it (e.g., when programming in assembly language). In most cases, however, it can cause a problem. Isso vai <emphasis> truque </emphasis> nosso compilador para armazenar os dados no <emphasis> ordem de bytes de rede </emphasis> . Em alguns casos, essa é exatamente a maneira de fazê-lo (por exemplo, ao programar em linguagem assembly). Na maioria dos casos, no entanto, isso pode causar um problema
Suppose, you wrote a sockets-based program in C. You know it is going to run on a <trademark class="registered">Pentium</trademark>, so you enter all your constants in reverse and force them to the <emphasis>network byte order</emphasis>. It works well. Suponha que você escreveu um programa baseado em soquetes em C. Você sabe que ele será executado em um <trademark class="registered"> Pentium </trademark> , então você insere todas as suas constantes ao contrário e as força para o <emphasis> ordem de bytes de rede </emphasis> . Isso funciona bem.
Then, some day, your trusted old <trademark class="registered">Pentium</trademark> becomes a rusty old <trademark class="registered">Pentium</trademark>. You replace it with a system whose <emphasis>host order</emphasis> is the same as the <emphasis>network order</emphasis>. You need to recompile all your software. All of your software continues to perform well, except the one program you wrote. Então, algum dia, seu velho confiável <trademark class="registered"> Pentium </trademark> torna-se um velho enferrujado <trademark class="registered"> Pentium </trademark> . Você o substitui por um sistema cujo <emphasis> ordem de host </emphasis> é o mesmo que o <emphasis> ordem de rede </emphasis> . Você precisa recompilar todo o seu software. Todo o seu software continua com bom desempenho, exceto pelo programa que você escreveu.
You have since forgotten that you had forced all of your constants to the opposite of the <emphasis>host order</emphasis>. You spend some quality time tearing out your hair, calling the names of all gods you ever heard of (and some you made up), hitting your monitor with a nerf bat, and performing all the other traditional ceremonies of trying to figure out why something that has worked so well is suddenly not working at all. Você desde então esqueceu que você tinha forçado todas as suas constantes para o oposto do <emphasis> ordem de host </emphasis> . Você gasta algum tempo de qualidade arrancando seu cabelo, chamando os nomes de todos os deuses que você já ouviu falar (e alguns inventando), batendo no monitor com um bastão de nerf e realizando todas as outras cerimônias tradicionais de tentar descobrir por que algo que funcionou tão bem, de repente não está funcionando.

Loading…

New source string a year ago
Browse all component changes

Things to check

Mismatched full stop

Source and translation do not both end with a full stop

Reset

Trailing space

Source and translation do not both end with a space

Fix string

Reset

Glossary

English Portuguese (Brazil)
No related strings found in the glossary.

Source information

Source string comment
(itstool) path: sect4/para
Source string location
book.translate.xml:5645
String age
a year ago
Source string age
a year ago
Translation file
books/pt_BR/developers-handbook.po, string 939