arfneto

Nada tem a ver o TeamViewer com isso. Esse é um programa de acesso remoto. Só citei o guia porque é uma boa documentação em português. TemViewer usa WOL porque é muito muito conveniente poder ligar o computador no meio da noite num escritório através de um telefone ou um script e acessar remotamente, rodar diagnósticos, backup na rede e desligar depois. Bem mais que poder ligar o computador com um assistente virtual que est;a no mesmo lugar que a gente e o botão de ligar. Não teria ligado o segundo roteador via porta WAN dele no outro teria? NUNCA deve fazer isso, mas é muito comum. Não se trata de "liberar portas" mas sim de encaminhar o tráfego para a porta certa. E se usa roteadores ligados (errado) via WAN deve cascatear todo encaminhamento, ou nada vai chegar lá na ponta onde está o PC. E não precisa ser a porta 9, pode ser qualquer uma, desde que chegue lá, ou não poderia ligar mais de um computador por rede. Esse protocolo WOL tem 40 anos e foi criado com um propósito sério, mas numa época em que a LAN era outra coisa.

Fez algum dos testes de que falei? Qual a velocidade de conexão que o SISTEMA indica para a conexão? Tentou trocrar os dois computadores de lugar simplesmente?

WOL nada tem a ver com wifi. Leu o guia do teamviewer? Que opção usou das 3 que listou? Leu as coisas que expliquei ?

Acho que já te disse, mas entenda que a velocidade na rede NADA tem a ver com a internet. E a chance de um vírus causar lentidão no acesso a rede é bem pequena. E também te disse como testar essa tal velocidade.

@taki26 Bem, na internet é que não se testa a velocidade de um micro. O computador sequer está ligado a internet, apenas à rede local. E a rede local pode ou não estar ligada a internet. E pode nem ser o tempo todo. Nada tem a ver uma coisa com a outra. Não, não precisava. Precisa de dois computadores claro. Imaginando que um deles rode Windows, a pasta Windows do sistema tem em geral mais de 10 gigabytes. Apenas copie está pasta para uma pasta temporária em outro micro na rede. Vai demorar o suficiente para identifiar alguma instabilidade na rede. Depois faça um download de algo grande, como a distribuição do Windows, que tem pouco mais de 6.3gigabytes hoje. E acompanhe os tempos. Basta olhar os gráficos na tela. Isso vai te dar uma boa ideia da estabilidade da rede no Windows. Ou Linux.

Mas nem tentou simplesmente levar o computador problemático até onde está algum dos outros e testar lá, e depois fazer o contrário, levando outro computador até o ponto distante? Com essa distância precisa usar os sinais dentro da norma. Não pode usar qualqer configuração porque tem muito mais metal por metro em certos pinos e com 85m vai perder potência.

Isso é apenas uma suposição. E o que seria "desconectar"? Precisa saber o que é antes de tirar muitas conclusões. Como identifica isso? O que acontece? O sistema reporta algo? Como aparece a conexão de rede? Qual o intervalo de lease do DHCP? Seria curto? Testou com um endereço fixo? Tentou um download de vários gigabytes e acompanhou a velocidade para ver se aparecem de fato interrupções? Tentou transferir uns gigabytes de seu micro para outro na rede local para ver o que acontece? Deve ser metódico para isolar o problema.

AX (wifi6 wifi6E) e AC (wifi 5) também usam 2.4Ghz. 80211.be (WIFI 7) também. Essas normas trouxeram mais frequências e mais canais, mas são compatíveis com os dispositivos antigos e também incluem conexões a 2.4Ghz.

Não entendi. Esse cabo da foto é o que comprou? Não existe placa de rede internet. Só placa de rede. Não precisa de inerne para ter rede. Mas precisa de rede para ter internet. Mesmo que sejam 2 pontos só. Isso quer dizer que já fez o simples e testou o mesmo computador com os outros dois cabos e os outros dois computadores com esse cabo certo? E qual foi o resultado? Um cabo CAT6 não vai fazer a menor diferença. Só gastou dinheiro. Sua placa de rede vai até 1Gigabit, o padrão de 1999. E para esse padrão a categoria 5 foi revista e desde enão tem o cbos Cat5E, que são perfeitamente adequados para essa velociade, em 95+5 metros. Ou uma velocidade até bem maior se forem cabos curtos e não estiver em um ambiente de muita interefrência. O cabo da foto parece folgado e está claramene fora do padrão, E dá pra imaginar que os cabos tem duas pontas e mostrar uma só de nada adianta. Que pino está ligado em que pino seria a pergunta normal a fazer. A primeira, E os testes de que falei. Esses são os padrões. Para curtas distâncias qualquer um deve servir, mas não é esperto divergir desses dois esquemas.

não é bem assim. Placas não "suportam internet". Sua placa nem deve estar conectada a internet mas sim a um roteador. Se desligar o roteador da internet a placa e a rede continuam funcionando. A velocidade da placa é dada pelo chipset instalado, nada tem a ver com internet ou plano de dados. Sua placa tem um chipset de rede embutido, e esse suporta conexões gigabit. ou FE a 100 mbps, ou mesmo a 10 mbps. Mas nada tem a ver com o que sua placa suporta. Essa placa tem 2 slots x1 e um slot x16. Isso quer dizer que pode instalar placas de rede nos 3. Pelo formato pode instalar 2 placas 2500G nos slots x1 e uma placa 10.000G no X16. Nada tem a ver com internet. Essas propriedades são um limite e não uma definição. Você usa isso para LIMITAR uma conexão abaixo da velocidade que seria normal. E precisa ver o que tem do outro lado do cabo, os cabos, os conectores e tal.

O simples: use esse https://www.microsoft.com/pt-br/software-download/windows11 para baixar um arquivo de distribuição no formato ISO do Windows. Tem 6.3 Gigabytes hoje, vem de um site confiável e que entrega boa velocidade. Durante o download acompanhe o desempenho do micro usando alguma ferramenta ou o próprio gerenciador, que você abre a qualquer momento digitando control-alt-del e escolhendo no gerenciador de tarefas por exemplo O que você espera é uma linha estável uma vez que o download comece, como a desse micro aí na figura. Alguns serviços ou sites podem e devem dar preferência para IPv6 e desabilitar pode não ser boa ideia. Não dá pra imaginar que IPv6 seja supérfluo depois de tanto tempo e trabalho. Numa hora dessas em que estiver lento apenas desative o wifi e ligue apenas seu pc para fazer os testes. Não terá dúvida de que está sózinho na rede.

@xlemes Que significa?

O que eu acho é que DNS não deve ser problema. E raramente é. A preocupação com DNS é com fraudes locais. Esse é sim um risco que sempre existe, e pouco pode um usuário fazer a respeito. Acho que é cedo para chamar um técnico sem ter mesmo algo objetivo pra dizer. Em geral é perda de tempo. E concordo que comprar outro roteador não seja assim garantia de sucesso. Se tem suspeita em relação ao wifi pode apenas desligar por uma hora quando acontece seu problema e ver se muda algo. É um comando simples e leva minutos. E na mesma hora veja se não tem algum intruso no wifi. Pode sempre usar whitelist no wifi e habilitar apenas os aparelhos que sabe que vão ser usados. Se ainda não fez isso conecte a TV via cabo. TV são bons consumidores de banda. Um vídeo a 4K pode gastar até uns 20/25 mbps. E tem mais tráfego dos aplicativos da TV. E se a TV está ligada a 2.4 é bem onde esses roteadores wifi são mais fracos. Teste seu tráfego com a internet. Veja se é estável baixando algo grande, tipo uma distribuição de Windows ou Linux e veja o desempenho e a estabilidade. Teste com outro micro. Transfira uma quantia grande de dados e acompanhe a velocidade. Deve ser muito metódico, quase paranóico, para tentar isolar um problema desses.

Hipotético servidor DNS lento só vai atuar no primeir acesso a um site ou serviço. Depois disso em o cache. Como pode medir facilmente, usar servidores DNS dentro da rede de um provedor do tamanho desse que usa quase sempre vai ser MUITO mais rápido que usar esses no Google ou Cloudfare, muito comuns. E de todo modo a resposta vai ser sempre a mesma. Se configura em vários lugares o mesmo endereço apenas perde tempo. Se usa DHCP esse MESMO endereço pode vir sempre automaticamente junto com o endereço IP. Essa é a razão de existir desses protocolos. Esse aparelho RF8115vw Tem 4 portas LAN e wifi dual-band AC. É como um AC1200 de outras marcas, com perto de 400/800 mbps em 2.4 e 5 GHz. Desativar um desses é algo curioso: vai perder 3 portas ethernet e as antenas dele. Em especial desativar o wifi para ficar com um roteador só só faz sentido em um ambiente muito muito pequeno, tipo 30 ou 40m2 ou um ambiente só. Porque? 5ghz raramente passa duas paredes antes de ficar inútil. E o seu roteador C6 tem configuração bem similar a esse da VIVO. Isso quer dizer que podia usar as duas redes 5ghz e melhorar muito a cobertura de wifi nessa frequência, que tem velocidade alta e alcance medíocre. E poderia usar 6 dispositivos via cabo e não apenas 3. ipo o dobro. Você não pode usar um roteador só em dois lugares e wifi a 5ghz não vai alem de duas paredes e a 2.4 é muito lerdo.

Esse comando faz a mesma coisa que você faz na interface grafica ao remover os protocolos ipv4 e ipv6 e se você não tinha mudado nada ele não vai fazer nada. O que tem lá naquelas chaves é apenas o modo de endereçamento e o endereço se for usar endereço fixo. Isso inclui os endereços de DNS e WINS, e o endereço alternativo para o caso do servidor DHCP não responder em tempo. Como qualquer um que tenha problemas com isso vai no primeiro minuto chegar exatamente essas configurações para a placa de rede, esse comando não serve em geral para NADA. Embora o help diga PS C:\Users\CDH> netsh int ip reset /? Usage: reset Parameters: none Remarks: Removes all user configured settings. Restarting computer is required before the default settings to be effect. PS C:\Users\CDH> Essas configurações passam a valer assim que o usuário clica no OK na inerface gráfica, então pode ser melhor usar o mouse do que o teclado nesse caso, economizando um reset. Limpe a cache do DNS: ipconfig /flushdns. Verifique as definições de rede e DNS nas definições do Windows. Certifique-se de que está a utilizar o DNS predefinido se não tiver a certeza da escolha. Sempre vejo essa recomendação, porque vem embutida naqueles scripts com vários comandos supostamente salvadores que vemos na internet. Entenda que o cache de DNS fica em memória e as entradas no cache tem um TTL e expiram em acho que 2 minutos. Não ajuda muito limpar isso a menos que tenha uma suspeita de fraude no momento. Apesar de muitas recomendações diferentes, se usa um provedor bem estabelecido e que tem na rede dele servidores DNS deve usar esses porque a latência é muito menor. Na dúvida faça o simples e meça usando algo como o DNSBench de tempos em tempos. E entenda que DNS não vai deixar a rede lenta. Trata-se da simples tradução de nomes e depois do primeiro acesso estarão em cache em sua máquina, talvez no seu roteador, e provavelmente em caches intermediários e nem vão chegar aos servidores que especificar

serviço de DNS não vai proporcionar um acesso melhor a internet. DNS apenas converte nomes para endereços e vice-versa, usando uma conexão na porta 53, em geral via UDP e em alguns casos via TCP. DNS nada tem a ver com ping e pouco ou nada a ver com jogos ou atividades específicas. Em geral, para provedores com alguma estrutura, o melhor servidor de DNS é o que está DENTRO da própria rede do provedor. É fácil de entender: a latência é muito menor se o servidor já estiver na rede do provedor. Por isso por exemplo servidores como 181.213.132.2 para a Claro e 200.204.0.10 para a VIVO costumam ter performance muito melhor que os do Google en 8.8.8.8 ou CloudFare em 1.1.1.1. O normal é simplesmente medir e a ferramenta mais comum é o DNSBench da GIBSON, e o resulado mais comum é o que acabei de dizer, pela razão que expliquei. Pouca chance disso ter algo a ver com DNS. Mais ainda, entenda que seu roteador pode ter cache de DNS, e seu computador certamente tem, de modo que suas requisiçÕes de endereço só vão parar no servidor na primeira vez em cada sessão. Depois disso ficam armazenadas em cache. Em Windows pode ver isso usando ipconfig /DisplayDNS. Essas opções que povoam a internet com comandos para limpar cache de DNS e de netbios e coisas assim são folclóricas. Isso é irrelevante. O cache fica em memória. Basta reiniciar o micro ou reabrir sessão. Mesmo hibernação preserva algumas dessas coisas, mas os registros em cache tem TTL, expiram em minutos, de modo que se demorar para religar a maquina de hibernação ou suspensão também vai zerar o cache. Notebooks não são formatados, apenas discos. O componente de rede em apenas 4 componentes básicos e cada placa de rede tem um driver. Para redefinir isso não precisa formatar o disco nem reinstalar o sistema. Exclua a placa no gerenciador de disposistivos e o driver se vai. Quanto ao stack tcp/ip em Windows tem o cliente para redes microsoft, o compartilhamento de arquivos, os protocolos v4 e v6, e alguns componentes que são instalados a partir desses. Basta excluir tudo e instalar de novo. Em geral tudo no automático. Há pouca razão para um usuário comum mudar alguma dessas configurações. Quando ao banco de dados, espero que tenha a rotina de manter backup de seus dados, de todo modo. Dois ou tres conjuntos, em locais separados

Não, MinGW não é um compilador. A distribuição inclui entre outras coisas um compilador gcc, mas pode usar MinGw e ter várias versões de gcc coexistindo na mesma máquina. E também pode instalar o MinGW sem o compilador, caso tenha um ou vários gcc já rodando em sua máquina. Considere: Direto de https://winlibs.com/ o lar do MinGW Não há formalização disso. Pode usar mais e mais "dimensões" enquanto houver memória, se tiver algum sentido em milhares de dimensões. E para testar pode usar, mesmo no Windows, binutils e make e um programa C para ir aumentando as dimensões. Use alocação dinâmica e crie do exato tamanho que precisa... É o simples e versátil.

Não existe de fato esse lance de matriz multidimensional em C ou C++, como tem em FORTRAN. Só existe escalar e vetor. Mas tem vetor de vetor, vetor de vetor de vetor e tal... Na prática quer dizer que [1] Sim, pode usar quantas "dimensões" quiser, e estarão lá alinhadas por linha a partir do endereço de início. char vetor[3][4] = {0}; declara vetor como um vetor com tres vetores de 4 char, por exemplo. [2] O limite vai depender de como cria isso. Se usa isso estático vai depender do tamanho de stack que seu programa está configurado para aceitar. Se vai alocar dinâmicamente o limite é a memória disponível em tempo de execução. MinGW não é um compilador. Nada tem a ver com isso. Seu compilador deve ser o gcc em Windows. Poste o código completo. Seu problema não está em nenhuma limitação do compilador ou da linguagem. Apenas acompanhe o tamanho de fato que está alocando. POSTE o código completo ou não há muito em que ajudar...

Como parece ter resolvido seu problema, vou mostrar como continuar o programa que mostrei 4X e ter algo que vai do arquivo até o propósito de criar um vetor na memória com uma linha para cada linha do arquivo. Acho que é legal ter algo assim no forum, que funcione para qualquer propósito, com fonte e exemplo e saída. Escrevendo em torno dos dados: Eis a saída que vai ser usada aqui no exemplo typedef struct { size_t incr; // tamanho do incremento size_t limit; // tamanho disponivel para uso size_t size; // tamanho em uso agora char** line; // as linhas } Array2D; Nada mais. É como em todo programa C, como expliquei antes: int main(int argc, char** argv); Todo programa C recebe uma lista de argumentos, e cada linha do arquivo de entrada pode ser vista assim. E os outros parâmetros? Simples. Não faz muito sentido ficar alocando memória a cada linha que o programa lê. E também não dá pra imaginar um tamanho máximo e alocar como 500 linhas com 80 colunas sempre, até uma linha ter mais de 80 colunas ou um arquivo ter mais que 500 linhas. Então tem os valores para o tamanho inicial, para cada incremento e para o tamanho total. E na criação o usuário pode escolher os valores que achar melhor. Encapsulamento e o princípio de única responsabilidade Esses são nomes chiques para uma coisa simples: todas as operações feitas com esse tal Array2D são feitas através de um ponteiro para a estrutura toda (encapsulamento) e dentro dela tem tudo o que importa. E cada função que opera com o Array como um todo faz uma e uma só coisa. Esse é o princípio de única responsabilidade, SRP. As funções em um exemplo mínimo Array2D* create_blk(size_t size, size_t incremento); Array2D* delete_blk(Array2D* block); int resize_blk(Array2D* block); int show_blk(Array2D* block, const char* msg); Array2D* load_file(const char* arquivo); O mínimo, mesmo: cria um bloco e retorna o endereço dele. apaga um bloco e retorna NULL aumenta o tamanho do bloco e retorna 0 se ok mostra o conteúdo de um bloco na tela e retorna 0 se ok load_file recebe o nome de um arquivo e carrega em um bloco, e retorna NULL se der erro ou o óbvio endereço do bloco criado. Claro que não vou tratar muitas condições de erro ou criar muitas operações aqui: trata-se apenas de um exemplo EXEMPLO: Usando isso com o arquivo "entrada.txt" Pokemon Megaman Megamente Kyrbi Kaku Eis como fica um programa que usa essas funções para carregar esse arquivo na memória e mostrar as linhas na tela. classifica em ordem alfabética e mostra de novo na tela apaga tudo #include "coisas.h" int main(int argc, char** argv) { char msg[80] = {0}; if (argc < 2) usage(); Array2D* test = load_file(argv[1]); if (test == NULL) return -1; sprintf( msg, "\n\n==> Carregando \"%s\" na memória", argv[1]); show_blk(test, msg); qsort(test->line, test->size, sizeof(void*), cmp_line); sprintf( msg, "\n\n==> \"%s\" depois do sort() na memória", argv[1]); show_blk(test, msg); test = delete_blk(test); return 0; }; Eis o que o programa mostra na tela Carregando "entrada.txt" na memória Criando bloco para 8 linhas, incremento = 16 linhas ==> Carregando "entrada.txt" na memória Bloco: 5 def 8 linhas. [Incremento = 16]: 1 Pokemon 2 Megaman 3 Megamente 4 Kyrbi 5 Kaku ==> "entrada.txt" depois do sort() na memória Bloco: 5 de 8 linhas. [Incremento = 16]: 1 Kaku 2 Kyrbi 3 Megaman 4 Megamente 5 Pokemon ***** Apagando bloco ***** Carregar o arquivo é essa operação: Array2D bloco = load_file("entrada.txt"); Nada mais. Entra o nome, se o arquivo existe sai o endereço do bloco. Eis um exemplo na tela do terminal para o programa chamado p... Forum > p Use: programa nome_do_arquivo Forum > cat entrada.txt Pokemon Megaman Megamente Kyrbi Kaku Forum > p entrada.txt Carregando "entrada.txt" na memória Criando bloco para 8 linhas, incremento = 16 linhas ==> Carregando "entrada.txt" na memória Bloco: 5 de 8 linhas. [Incremento = 16]: 1 Pokemon 2 Megaman 3 Megamente 4 Kyrbi 5 Kaku ==> "entrada.txt" depois do sort() na memória Bloco: 5 de 8 linhas. [Incremento = 16]: 1 Kaku 2 Kyrbi 3 Megaman 4 Megamente 5 Pokemon ***** Apagando bloco ***** Forum > Claro, em coisas.h tem as declarações #pragma once #include <stdio.h> #include <stdlib.h> #include <string.h> typedef struct { size_t incr; // tamanho do incremento size_t limit; // tamanho disponivel para uso size_t size; // tamanho em uso agora char** line; // as linhas } Array2D; Array2D* create_blk(size_t size, size_t incremento); Array2D* delete_blk(Array2D* block); int resize_blk(Array2D* block); int show_blk(Array2D* block, const char* msg); Array2D* load_file(const char* arquivo); int cmp_line(const void*, const void*); void usage(); Claro que para usar qsort precisa de uma função de comparação e ela está aí. usage() é clássica em C e é mostrada se o cara esquece de dar o nome do arquivo na hora de rodar o programa. O código para as outras funções #include "coisas.h" int cmp_line(const void* one, const void* other) { return strcmp( *((const char**)one), *((const char**)other)); } Array2D* create_blk(size_t size, size_t increment) { Array2D* nb = (Array2D*)malloc(sizeof(Array2D)); if (nb == NULL) return NULL; char msg[80] = {0}; fprintf( stderr, "Criando bloco para %llu linhas, incremento = %llu " "linhas\n", size, increment); nb->incr = increment; nb->limit = size; nb->size = 0; nb->line = (char**)malloc(sizeof(char*) * size); return nb; } Array2D* delete_blk(Array2D* blk) { if (blk == NULL) return NULL; fprintf(stderr, "\n\n***** Apagando bloco *****\n\n"); for (size_t i = 0; i < blk->size; i += 1) free(blk->line[i]); // free lines free(blk->line); // free block free(blk); // free struct return NULL; } int resize_blk(Array2D* nb) { const size_t new_sz = nb->limit + nb->incr; char* new_block = realloc(nb->line, (new_sz * sizeof(char*))); if (new_block == NULL) { fprintf( stderr, "\tErro ao tentar aumentar bloco para %llu " "lines\n", new_sz); return -1; } nb->limit = new_sz; nb->line = (char**)new_block; return 0; } // resize_blk() int show_blk(Array2D* bl, const char* msg) { if (msg != NULL) printf("%s\n", msg); if (bl == NULL) { printf("show(): bloco não alocado\n"); return -1; } printf( " Bloco: %llu de %llu linhas. [Incremento = " "%llu]:\n", bl->size, bl->limit, bl->incr); for (size_t i = 0; i < bl->size; i += 1) printf("%4llu\t%s\n", 1 + i, bl->line[i]); return 0; } Array2D* load_file(const char* f_name) { // carrega o arquivo para dentro do Array_2D if (f_name == NULL) return NULL; fprintf( stderr, "Carregando \"%s\" na memória\n", f_name); FILE* F = fopen(f_name, "r"); if (F == NULL) return NULL; // arquivo aberto // cria o bloco: comeca com 8, incremento = 16 Array2D* nb = create_blk(8, 16); char line[250]; char* p = &line[0]; p = fgets(p, sizeof(line), F); while (p != NULL) { // ainda cabe? if (nb->size >= nb->limit) { resize_blk(nb); printf( "Bloco estendido para um total de %llu " "linhas\n", nb->limit); } // copia a linha // se a string termina em `\n` apaga size_t fim = strlen(p) - 1; if (p[fim] == '\n') p[fim] = 0; nb->line[nb->size] = (char*)malloc(1 + strlen(p)); strcpy(nb->line[nb->size], p); nb->size += 1; // le a proxima p = fgets(p, sizeof(line), F); }; // while() fclose(F); return nb; } void usage() { fprintf(stderr, "Use: programa nome_do_arquivo\n"); exit(EXIT_FAILURE); } É isso. Funciona para qualquer coisa. Eis um exemplo usando o próprio arquivo coisas.h ==> Carregando "coisas.h" na memória Bloco: 22 de 24 linhas. [Incremento = 16]: 1 #pragma once 2 #include <stdio.h> 3 #include <stdlib.h> 4 #include <string.h> 5 6 typedef struct 7 { 8 size_t incr; // tamanho do incremento 9 size_t limit; // tamanho disponivel para uso 10 size_t size; // tamanho em uso agora 11 char** line; // as linhas 12 13 } Array2D; 14 15 Array2D* create_blk(size_t size, size_t incremento); 16 Array2D* delete_blk(Array2D* block); 17 int resize_blk(Array2D* block); 18 int show_blk(Array2D* block, const char* msg); 19 20 Array2D* load_file(const char* arquivo); 21 int cmp_line(const void*, const void*); 22 void usage(); ==> "coisas.h" depois do sort() na memória Bloco: 22 de 24 linhas. [Incremento = 16]: 1 2 3 4 5 char** line; // as linhas 6 size_t incr; // tamanho do incremento 7 size_t limit; // tamanho disponivel para uso 8 size_t size; // tamanho em uso agora 9 #include <stdio.h> 10 #include <stdlib.h> 11 #include <string.h> 12 #pragma once 13 Array2D* create_blk(size_t size, size_t incremento); 14 Array2D* delete_blk(Array2D* block); 15 Array2D* load_file(const char* arquivo); 16 int cmp_line(const void*, const void*); 17 int resize_blk(Array2D* block); 18 int show_blk(Array2D* block, const char* msg); 19 typedef struct 20 void usage(); 21 { 22 } Array2D; ***** Apagando bloco ***** Forum > Sugiro testar em sua máquina e escrever de volta se não entender a ideia.

Não, não é assim. Você pode ter 8 maquinas virtuais em rede, todas hospedadas em uma máquina sem placa de rede. As placas de rede são tão virtuais quanto a máquina virtual. Em ambientes cloud vem até a necessidade de um switch virtual quando as VM que você usa são cooperativas. Não existe essa noção de wifi virtual. Todas as conexões da VM são virtuais. O que existe é em algum momento algo como um comando "attach" que liga a rede da VM com a rede do host, ou algum gateway. Uma ponte de rede (bridge) por exemplo pode ligar sua placa de rede virtual com sua placa de rede no host. Pode usar NAT também, ou um switch virtual. Não faz diferença se do lado do host a placa é wifi ou não. Se vai usar TCP/IP deve ter ethernet. Nada mais. wifi é ethernet. E half duplex. E cada conexão usa antenas dos dois lados. Se precisa ligar exclusivamente uma VM via wifi por alguma razão, uma possibilidade é fazer como te expliquei, usando um adapador USB. Claro que isso nada tem a ver com wifi porque pode fazer o mesmo com um adaptador USB para RJ45. Apenas vai trazer uma conexão USB física para controle exclusivo da VM. E daí usa os recursos que esse dispositivo te oferece. É como ligar uma placa de vídeo para uso exclusivo da VM (claro, desde que seu computador tenha mais de uma).

Entenda que o próprio shell foi escrito em C. Pode fazer qualquer coisa em C e muitas vezes usar um bat no Windows ou um script no Linux só vai atrasar as coisas. E mesmo assim há opções ais interessantes para transformar texto, como o clássico awk. Não entendi o que quer dizer. Onde não pode fazer comparações? O que quer automatizar que não pode fazer em C? O sistema foi escrito em C. O programa que eu te mostrei faz tudo o que precisa fazer. E até te mostrei como acessar as letras uma a uma em cada linha. ? Leu a parte em que falei sobre escrever uma série de printf de uma linha? Não deve escrever desse modo. E entenda que isso que escreveu é um loop: escreva como tal. Não há nada errado no que te mostrei. Mas seu programa tinha muitos problemas. Se resolveu algum devia ir postando as versões novas ou vai ser difícil te ajudar. Sobre uma pergunta que fiz: você tem um livro ou mais? Tem alguma referência de C? O que escreveu com relação a FILE e algumas conversões que usou não fazem sentido. Rodou o programa que te mostrei? Entendeu? Entendeu o que seria "escrever em torno dos dados, o que eu tentei mostrar nos 4 programas?

Resumindo: você não disse a velocidade de conexão que seu computador reporta para a conexão com a rede. Se está em algo como 187/163 como mostrou (não está claro que aqueles números se referam aseu computador) então a conexão está a 1000. Como eu disse, a conexão via cabo vai estar a 10, 100 ou 1000 mbps. E repetindo o que eu disse: deve testar a velocidade do micro na rede e não com esses medidores abstratos de conexão com a internet. E aí ver se seu computador está mesmo transmitindo e recebendo sem gargalos. Claro, desde que tenha um outro computador na mesma rede. E se ele estiver ok então seu problema não está aí. De todo modo, se não tiver mais nada usando a internet, daria pra esperar um pouco mais da conexão com a internet, algo perto de 300/350.

Sua placa de rede nada tem a ver com a velocidade contratada para acesso a internet. Ela provavelmente sequer está ligada na internet mas sim a uma das portas do modem, na tal LAN, a rede local. E lá é onde deve ver a velocidade da conexão, na LAN. Se usa Windows está na nas propriedades da placa de rede, e vai estar marcando 10, 100 ou 1000 para o seu caso. Se a placa é Fast Ethernet não vai nunca mostrar tráfego além disso. Pode esperar até uns 90 ou 95 mbps. Se a placa for gigabit não vai mostrar além de uns 900/950, e de novo nada tem a ver com a internet: deve testar transmitindo e recebendo algo dentro de sua rede local. Se desligar da internet sua placa de rede continua funcionando com a velocidade nominal dela. Cabo CAT 6 é um desperdício para essas velocidades. Precisaria disso para 10.000 mbps e mesmo assim até uns 10m provavelmente mesmo o cabo comum 5E funcionaria, a menos que esteja dentro de uma fábrica.

F7: bidimensional é a grafia correta, como em dimensão. Seu programa lê lexto e mostra texto, então mostre texto aqui e não essas imagens gigantes copiadas de sua tela. Ajude outros a ajudarem você: poste um mínimo arquivo de teste que mostra o que quer fazer, e um exemplo do seu problema acontencendo, em texto. Isso seria algo melhor que as duas telas gigantes: entrada.txt Pokemon Megaman Megamente Kyrbi Kaku Porque assim alguém pode copiar isso e colar em um arquivo e tentar reproduzir seu problema em minutos. E poste a saída do seu programa. Mas nem posso postar aqui a saída do programa que mostrou, porque ele sequer compila direito ainda. Sobre o programa: Quase todo o código está comentado. Qual o propósito? Esse comando, por exemplo: strncpy( &Text_Read[i][p], (char*)fgets( ((char*)getchar()), 1 * sizeof(char), ((FILE*)printf("%c", *(&One_Letra2)))), 1 * sizeof(char)); é algo que deve muito evitar, em especial se está começando a programar nessa linguagem. No caso de seu programa está errado mesmo, mas é algo que deve evitar mesmo que saiba o quie está fazendo. São muitas coisas que podem dar errado, isso se a ideia em si estiver certa. `fgets` pode dar errado. Não está sequer testando e já passa o valor como argumento para `strncpy`. Não é boa ideia. leia o manual: `printf` retorna um `int`. Qual seria o sentido de converter para `FILE~`, algo que nem é suposto para ser tratado pelo programador? o operador `sizeof` retorna 1 para `char`. Então tudo isso seria para de algum modo copiar uma letrinha e um `NULL`? pra que `strncpy`? Isso é algo que poderia ter comentado... Não seria melhor ver agora o tamanho da string e alocar do tamanho certo e copiar usando simplesmente strcpy? Está certo de entende o que é `FILE*`? Tem um livro? Mais sobre o código Seu programa tem muitos dos erros comuns que vemos aqui, e então vou copiar de uma lista que tenho e listar umas coisas que provavelmente deve evitar Não use acentos em nomes de variáveis ou comentários. Evite mesmo em strings a menos que o enunciado exija. Não vai aprender nada e só vai ter problemas. Mais ainda evite usar Unicode e coisas como emojis. Nada acrescenta ao código e não sair em muitas telas, ou vai sair outra coisa. E se imprimir o programa pode não sair nada ou algum lixo. Evite comentários como "main é a função principal" ou "declaração de variáveis" ou coisas óbvias desse tipo. Comente o porque está fazendo algo, escreva para você mesmo no futuro, tipo daqui a 2 dias quando pode não lembrar para que era aquele ponteiro, por exemplo. evite retornar void de funções: em geral é um desperdício. E muitas vezes um erro. Use argumentos nas funções, e retorne algo delas. É mais esperto e expressivo. Use alguma ordem em suas funções, como a ordem alfabética por exemplo. Vai gostar disso quando seu programa tiver 50 funções ao invés de umas poucas. Muitos IDE mostram uma lista das funções, em geral na ordem em que foram declaradas, de modo que você pode clicar no nome e o editor vai direto para o código, mas se estiverem em ordem é claro que você só ganha. Nunca use variáveis globais. Isso é um pesadelo e sempre vai cair na sua cabeça. Em geral é proibido em empresas e escolas. Não declare NADA que use memória fora de main(). Não declare mais que uma variável por linha. Não acrescenta nada e só dificulta a leitura. Inicialize todas as variáveis. Nunca leia valores do teclado para alimentar seu programa antes dele estar rodando. Só vai te atrasar e não acrescenta absolutamente nada. Use constantes, use funções que retornam a estrutura preenchida. Leia de arquivos: é trivial em C. Ao terminar os testes aí sim incorpore a leitura. Um programa interativo é chato para testar. Durante o desenvolvimento ninguém quer interagir com o programa. Nunca escreva um programa interativo, mesmo que seja o objetivo final. Alinhe seu código com algum critério. Evite longas linhas com mais de 60 colunas. Use nomes significativos para as variáveis e fuja de coisas como aux, aux1 e aux2. E não use nomes de variáveis enormes porque em uma expressão fica muito difícil de ler. não use fflush(): isso só está definido para fluxos de saída. Em alguns compiladores pode até funcionar, mas é um sinal de fez algo errado e não sabe como consumir os dados. não use setbuf a menos que saiba a razão de fazer isso. streams usam buffers porque é esperto e não o contrário. Não existe "lixo de teclado": necessidades como de flush() na entrada indicam apenas que não entendeu bem o que está lendo e o que é a entrada via teclado, free form: o usuário pode digitar qualquer coisa e é o seu programa que tem que se virar O teclado tem ao menos 105 teclas de liberdade e o usuário pode digitar qualquer coisa em qualquer ordem. evite ler do teclado a menos que seja o objetivo do problema. Ler de arquivos é muito mais simples, seguro e fácil de reproduzir. Não há razão para ficar parado em frente a tela minutos inventando nomes de campos e coisas assim: o efeito é que vai acabar não testando direito porque é difícil controlar e repetir testes. Não misture entrada de dados ou formatação com a apresentação dos dados ou a lógica do programa, Isso é um desastre para manutenção e desenvolvimento. Um printf() de 6 linhas é **muito**, mas muito melhor que 6 printf() de 1 linha. E se só vai mostrar o texto puts() é ainda melhor e dezenas de vezes mais rápido que uma série de printf(). Escreva seu programa em torno dos dados. O que quer criar é o que todo programa `C` recebe: uma lista de strings. Esse é o protótipo normal de `main`: int main( int argc, char** argv); E são os argumentos que seu programa --- e todo programa `C` recebe: uma lista de strings com o que o usuário digitou na linha de comando. O primeiro argumento é sempre o nome do programa. Isso deveria ser ensinado no PRIMEIRO programa do aluno, aquele tal `Hello World`. Mas não sou eu quem ensina ou decide isso Os dados: o que o programa recebe? O que o programa cria? O programa recebe o nome de um arquivo e cria uma lista de strings. Igualzinho ao que o sistema faz para todo programa `C`, como eu disse. Então faça igual, já que dá certo para todo programa vai dar certo para o seu: char nome_arquivo[250]; const char[] arquivo_padrao = "entrada.txt"; typedef struct { unsigned n_linhas; // quantas linhas no arquivo? char** L; // o vetor de linhas } Array; Já seria um bom começo: tem onde ler o nome do arquivo. tem um nome padrão para o caso do cara não digitar nada. E assim para testar não tem que ficar digitando nomes de arquivo duzentas vezes. E pode ter arquivos de teste já separados. na saída vai ter o tal `Array` onde diz que o texto carregado tem n_linhas e as linhas vão estar todas arrumamindas no vetor L. Parece simples assim. E #include <stdio.h> typedef struct { size_t N; // quantas linhas no arquivo? char** L; // o vetor de linhas } Array; int main(int argc, char** argv) { char nome_arquivo[250]; const char arquivo_padrao[] = "entrada.txt"; return 0; } já compila e roda. Claro, só para apoio moral porque não faz nada. São mesmo duas dimensões. De todo modo entenda que C sequer tem arrays multidimensionais, como FORTRAN. Só existe array. Mas tem array de array, array de array de array e assim por diante... Então se declarar o simples char** Linha; e gravar seu arquivo lá, vai ter a linha 0 em Linha[0], a linha 3 em Linha[3] e tal. Linha[0] é o que? char*, assim foi declarado. Então Linha é char** *Linha é char*, Linha[0] é char* **Linha é uma letrinha, char, assim foi declarado. assim sendo, Linha[12][0] é a primeira letra da linha 13 a ultima letra da terceira linha seria o que? Seguindo com o exemplo que mostrei: #include <stdio.h> #include <stdlib.h> typedef struct { size_t N; // quantas linhas no arquivo? char** L; // o vetor de linhas } Array; int main(int argc, char** argv) { char nome_arquivo[250]; const char arquivo_padrao[] = "entrada.txt"; char* uma = "uma linha"; char* outra = "outra linha"; Array exemplo = {.L = NULL, .N = 0}; printf("exemplo tem %llu linhas\n", exemplo.N); exemplo.L = (char**)malloc(2 * sizeof(char*)); exemplo.L[1] = uma; exemplo.L[0] = outra; exemplo.N = 2; printf("exemplo tem %llu linhas\n", exemplo.N); return 0; } Isso mostra exemplo tem 0 linhas exemplo tem 2 linhas Mas é claro que vai querer mostrar o que tem dentro do vetor, as linhas, então uma função assim int ch_mostra(Array*,const char*); // mostra as linhas na tela Seria a popular "mão na roda" e ainda aceita um título pra você não ter que ficar colocando os ultra chatos printf aqui e ali... Seria difícil escrever? int ch_mostra(Array* arr,const char* msg) { if (arr == NULL) return - 1; // sem linhas if (msg != NULL) printf("%s", msg); printf(" Vetor tem %llu linhas\n", arr->N); for (size_t i = 0; i < arr->N; i += 1) printf("#%llu\t\"%s\"\n", i, arr->L[i]); printf("\n******\n\n"); return 0; } 10 linhas está ok. E mudando o programa aí de cima #include <stdio.h> #include <stdlib.h> typedef struct { size_t N; // quantas linhas no arquivo? char** L; // o vetor de linhas } Array; int ch_mostra(Array*,const char*); // mostra as linhas na tela int main(int argc, char** argv) { char nome_arquivo[250]; const char arquivo_padrao[] = "entrada.txt"; char* uma = "uma linha"; char* outra = "outra linha"; Array exemplo = {.L = NULL, .N = 0}; ch_mostra(&exemplo, "[array vazio]\n\n"); exemplo.L = (char**)malloc(2 * sizeof(char*)); exemplo.L[1] = uma; exemplo.L[0] = outra; exemplo.N = 2; ch_mostra(&exemplo, "[array deve ter duas linhas]\n\n"); return 0; } int ch_mostra(Array* arr,const char* msg) { if (arr == NULL) return - 1; // sem linhas if (msg != NULL) printf("%s", msg); printf(" Vetor tem %llu linhas\n", arr->N); for (size_t i = 0; i < arr->N; i += 1) printf("#%llu\t\"%s\"\n", i, arr->L[i]); printf("\n******\n\n"); return 0; } E na tela mostra [array vazio] Vetor tem 0 linhas ****** [array deve ter duas linhas] Vetor tem 2 linhas #0 "outra linha" #1 "uma linha" ****** É melhor escrever em torno dos dados e começar assim. E sobre a última letra da última linha? // 'len' = tamanho da ultima linha size_t len = strlen(exemplo.L[exemplo.N - 1]); char ultima = exemplo.L[exemplo.N - 1][len - 1]; printf( "\n\n\tUltima letra da ultima linha: '%c'\n", ultima); E colocando isso no programa #include <stdio.h> #include <stdlib.h> typedef struct { size_t N; // quantas linhas no arquivo? char** L; // o vetor de linhas } Array; int ch_mostra( Array*, const char*); // mostra as linhas na tela int main(int argc, char** argv) { char nome_arquivo[250]; const char arquivo_padrao[] = "entrada.txt"; char* uma = "uma linha"; char* outra = "outra linha"; Array exemplo = {.L = NULL, .N = 0}; ch_mostra(&exemplo, "[array vazio]\n\n"); exemplo.L = (char**)malloc(2 * sizeof(char*)); exemplo.L[1] = uma; exemplo.L[0] = outra; exemplo.N = 2; ch_mostra(&exemplo, "[array deve ter duas linhas]\n\n"); // 'len' = tamanho da ultima linha size_t len = strlen(exemplo.L[exemplo.N - 1]); char ultima = exemplo.L[exemplo.N - 1][len - 1]; printf( "\n\n\tUltima letra da ultima linha: '%c'\n", ultima); free(exemplo.L); return 0; } int ch_mostra(Array* arr, const char* msg) { if (arr == NULL) return -1; // sem linhas if (msg != NULL) printf("%s", msg); printf(" Vetor tem %llu linhas\n", arr->N); for (size_t i = 0; i < arr->N; i += 1) printf("#%llu\t\"%s\"\n", i, arr->L[i]); printf("\n******\n\n"); return 0; } Que mostra [array vazio] Vetor tem 0 linhas ****** [array deve ter duas linhas] Vetor tem 2 linhas #0 "outra linha" #1 "uma linha" ****** Ultima letra da ultima linha: 'a' Para que isso? Só para mostrar como acessar as letras dentro da estrutura.

@Fernando Cardoso de Melo Você pode virtualizar o protocolo, mas o rádio não... Nem as antenas da placa. Se a própria máquina é virtual e as redes são virtuais e placas, onde entra um rede wifi diferente? As conexões de rede da máquina virtual são, claro, virtuais, e pode criar várias. Se por alguma razão precisa de outras rede wifi em cada VM use por exemplo adaptadores USB para cada VM que precisa disso. No host use o comando apropriado para anexar o dispositivo USB físico à máquina virual apropriada e instale o sw como outro qualquer.